The Simplicity of Express.js.
The Speed of Native C.

# 1. Build release binary
make clean && make demo

# 2. Launch 4-worker cluster in background
cd examples/todo_sqlite && QUIET=1 WORKERS=4 ./cexpress_demo

# 3. In another terminal, run standalone wrk benchmarks on /ping
wrk -t8 -c100 -d15s http://127.0.0.1:8080/ping
wrk -t8 -c1000 -d15s http://127.0.0.1:8080/ping

# 4. Or run the full automated stress battery with memory profiling
./scripts/stress_test.sh

# 5. Same battery against Linux (epoll; CEXPRESS_EVENT_LOOP=io_uring for io_uring) in Docker
./scripts/docker_stress_test.sh

# 6. Pure request-path microbenchmark (no sockets)
make bench

# Run entire test suite under ASan + UBSan
make clean && make SANITIZE=1 test

# Run mutation fuzzer on HTTP parser (1,000,000 iterations)
make fuzz

/* Includes routing, response builders, middlewares, HTTP parser, static files, the arena allocator and yyjson */
#include "cexpress.h"

gcc-16 -Wall -Wextra -std=c11 -O2 -Ipath/to/lib -o my_app main.c path/to/libcexpress.a   # Linux: add -D_GNU_SOURCE and -luring

#include "cexpress.h"
#include <stdio.h>

void handler_home(const Request *req, Response *res) {
    (void)req;
    res_send(res, "Hello from CExpress!");
}

int main(void) {
    App app;
    app_init(&app);

    app_get(&app, "/", handler_home);

    printf("Listening on http://localhost:8080\n");
    app_listen(&app, 8080);

    app_destroy(&app);
    return 0;
}

app_get(&app, "/users", handler_get_users);
app_post(&app, "/users", handler_create_user);
app_put(&app, "/users/:id", handler_update_user);
app_patch(&app, "/users/:id", handler_patch_user);
app_delete(&app, "/users/:id", handler_delete_user);

app_get(&app, "/orgs/:org/repos/:repo", handler_repo);

void handler_repo(const Request *req, Response *res) {
    const char *org  = req_get_param(req, "org");
    const char *repo = req_get_param(req, "repo");

    char body[128];
    snprintf(body, sizeof(body), "Repository: %s/%s", org, repo);
    res_send(res, body);
}

Router api_router;
router_init(&api_router);

/* Scoped to /api */
router_get(&api_router, "/health", handler_health);
router_get(&api_router, "/metrics", handler_metrics);

/* Mounts routes to /api/health and /api/metrics */
app_mount(&app, "/api", &api_router);

void mw_logger(const Request *req, Response *res, MiddlewareChain *chain) {
    /* 1. Pre-handler processing */
    chain_next(chain);

    /* 2. Post-handler inspection (res->status is finalized) */
    printf("%s %s -> %d\n", req->method, req->path, res->status);
}

/* Register app-wide middleware */
app_use(&app, mw_logger);

/* Register prefix-scoped middleware (only runs for /admin/*) */
app_use_prefix(&app, "/admin", mw_admin_auth);

/* Register per-route middleware */
app_post_mw(&app, "/checkout", handler_checkout, (Middleware[]){mw_auth}, 1);

void mw_guard(const Request *req, Response *res, MiddlewareChain *chain) {
    if (!is_authorized(req)) {
        chain_error(chain, 401, "Invalid or missing API key");
        return;
    }
    chain_next(chain);
}

/* Register custom error handler */
void custom_error_handler(int status, const char *msg, const Request *req, Response *res) {
    (void)req;
    res_status(res, status);
    char json[256];
    snprintf(json, sizeof(json), "{\"error\":\"%s\",\"status\":%d}", msg, status);
    res_json(res, json);
}

app_use_error(&app, custom_error_handler);

void handler_inspect(const Request *req, Response *res) {
    const char *query_sort = req_get_query(req, "sort");
    const char *auth_hdr   = req_get_header(req, "Authorization");
    const char *session    = req_get_cookie(req, "session_id");

    /* Set status and custom headers */
    res_status(res, 200);
    res_set_header(res, "X-Engine", "CExpress");

    /* Send JSON */
    res_json(res, "{\"status\":\"ok\"}");
}

/* Setting a cookie with SameSite, Max-Age, and HttpOnly */
CookieOptions opts = {
    .max_age = 86400,
    .http_only = 1,
    .secure = 1,
    .same_site = COOKIE_SAMESITE_STRICT
};
res_set_cookie(res, "auth_token", "secure_secret", &opts);

/* Clearing a cookie */
res_clear_cookie(res, "auth_token", "/");

/* Performing a 302 Redirect */
res_redirect(res, 0, "/dashboard");

void handler_stream(const Request *req, Response *res) {
    (void)req;
    res_set_header(res, "Content-Type", "text/plain");

    /* Stage trailer (declares Trailer: Server-Timing in headers) */
    res_set_trailer(res, "Server-Timing", "app;dur=24.2");

    /* Write chunks incrementally */
    res_write(res, "Chunk 1\n", 8);
    res_write(res, "Chunk 2\n", 8);

    /* Emits terminal 0\r\n, trailers, and terminating CRLF */
    res_end(res);
}

void handler_download(const Request *req, Response *res) {
    (void)req;
    if (res_send_file(res, "application/pdf", "reports/report.pdf") != 0) {
        res_status(res, 404);
        res_send(res, "Report not found");
    }
}

/* GET /static/app.css -> serves public/app.css */
app_serve_static(&app, "/static", "public");

/* Multipart File Uploads */
const char *content_type = req_get_header(req, "Content-Type");
char boundary[128];
MultipartForm form;
if (content_type == NULL || !multipart_parse_boundary(content_type, boundary, sizeof(boundary)) ||
    parse_multipart_body(req->body, (size_t)req->content_length, boundary, &form) < 0) {
    res_status(res, 400);
    res_send(res, "Bad multipart body");
    return;
}

for (int i = 0; i < form.part_count; i++) {
    if (form.parts[i].filename[0] != '\0') {
        printf("File uploaded: %s (%zu bytes)\n", form.parts[i].filename, form.parts[i].data_len);
    }
}

/* Parse incoming JSON */
yyjson_alc alc = arena_yyjson_alc(res->conn->arena);
yyjson_doc *doc = yyjson_read_opts(req->body, (size_t)req->content_length, 0, &alc, NULL);
if (doc != NULL) {
    const char *name = yyjson_get_str(yyjson_obj_get(yyjson_doc_get_root(doc), "name"));
    /* name points into the arena: use it before the handler returns */
}

/* Construct and send JSON */
yyjson_mut_doc *out = yyjson_mut_doc_new(&alc);
yyjson_mut_val *obj = yyjson_mut_obj(out);
yyjson_mut_doc_set_root(out, obj);
yyjson_mut_obj_add_str(out, obj, "status", "active");
char *text = yyjson_mut_write(out, 0, NULL); /* libc-malloc'd */
if (text != NULL) { res_json(res, text); free(text); }