Familiar to write.
Explicit by design.

01 / The idea

The good parts of Zap.
A fresh foundation.

Zap made building Zig web applications approachable. Baz carries forward its App and endpoint ergonomics, with a new API and a separate, bounded HTTP engine underneath.

The framework and its HTTP engine are written in Zig. Baz replaces Zap’s facil.io C foundation with bounded/http.

Native Windows support, too. Baz runs on Linux, macOS, and Windows x64—an addition to Zap’s platform support. Read the native evidence →

Baz is a new framework, with its own package and API. The migration guide maps familiar Zap concepts to their Baz equivalents.

02 / An ordinary Zig App

A struct. A method.
A clear place for everything.

Define your shared state, choose App(Shared), and register an endpoint. The context gives you the request, your state, route captures, and a bounded response draft.

const Hello = struct {
    pub fn get(_: *Hello, ctx: *Context) !void {
        const query = try ctx.request.query();
        if (query.firstRaw("name")) |param| {
            var decoded: [1024]u8 = undefined;
            const name = try web.params.percentDecodeInto(param.value_raw, &decoded);
            return ctx.response.text(200, name); // copies before stack storage ends
        }
        return ctx.response.text(200, ctx.shared.greeting);
    }
};

fn progress(ctx: *Application.Context) !void {
    try ctx.response.header("Cache-Control", "no-cache");
    var stream = try ctx.response.stream(200, "text/plain; charset=utf-8", .{});
    const out = stream.writer();
    try out.writeAll("Starting…\n");
    try out.flush();
    try ctx.sleep(.fromMilliseconds(500));
    try out.print("Completed step {d} of {d}\n", .{ 1, 2 });
    try out.flush();
    try ctx.sleep(.fromMilliseconds(500));
    try out.writeAll("Done.\n");
    try stream.finish();
}

const Shared = struct {};
const Application = web.App(Shared);

fn index(ctx: *Application.Context) !void {
    return ctx.response.borrowBody(200, "text/html; charset=utf-8", @embedFile("assets/serve_index.html"));
}

From a background job to a live page.

The complete jobs example puts Mustache, cookie sessions and SSE together. A startup producer publishes progress; bounded notifications wake waiting streams while their workers remain available. Event IDs support explicit, finite replay, and each resumed callback checks the session again. Run the application → See the job studio → Read the SSE and notification API →

03 / Data stays data

No guessing what
your parameters mean.

Query parameters and URL-encoded forms are ordered lists of raw text slices. Decode when needed, into a buffer you supply. Repeated fields remain repeated fields.

04 / Built on bounded/http

Application ergonomics above.
HTTP ownership underneath.

Baz imports bounded_http as a pinned external dependency. The engine stays independently usable. Baz supplies the application layer: routing, request views, endpoint composition, and responses.

05 / Get started

A working App in one command.

Use exact Zig 0.16.0 and Python 3. Clone Baz, then start the demo. The pinned HTTP engine is fetched automatically.

git clone https://github.com/technologylab-ai/baz.git
cd baz
zig build run-app -Doptimize=ReleaseSafe -- --port 8080

curl 'http://127.0.0.1:8080/hello?name=Hello%20Zig'
curl --data 'value=x+y%2Bz' http://127.0.0.1:8080/form
curl -F 'files[]=@.zig-version' http://127.0.0.1:8080/upload

The current executable serves IPv4 loopback over plain HTTP/1.1. Stop it with Ctrl-C. On Windows, use curl.exe; executables have an .exe suffix. For embedding Baz in your own project, follow the package guide and independent consumer fixture.

06 / Explore the examples

Examples you can run.

Twenty Zap ports and a new streaming example, using Baz’s public API. Every card opens maintained source in the reader. Pick a small example, then follow its types.

Build real pages with Mustache templates: a greeting form, typed user cards, and reusable partials. Parse once at startup and render straight into reserved HTML storage. The complete Zig example is just 52 lines → See the rendered preview →

24 of 24 examples

zig build examples -Doptimize=ReleaseSafe
zig build run-http_params -Doptimize=ReleaseSafe -- --port 8080

Cookies and redirects are public APIs, with explicit expiry and a local login/logout example. Middleware, authentication policy and session storage remain explicit application code. Read the complete catalog and its deliberate adaptations →

07 / Measured results

A first comparison.
The conditions included.

A basic same-host loopback comparison with Zap, measured on 6 September 2026. These results describe the initial Baz prototype c152e59, before package extraction.

macOS: Apple M3 Max. Linux: Intel Core Ultra 7 258V. Three paired trials per profile; one-second warmup and three-second measurements. ReleaseSafe with Zig assertions enabled, one server thread, 128 connection slots, a 13-byte response, keep-alive, no pipelining, and no CPU affinity.

All 24 measured trials completed with zero wrk-reported socket or non-2xx/3xx errors. Exact responses were checked before and after timing, rather than for every timed response. The report preserves ranges, versions, commands, raw results, and cleanup evidence.

08 / What comes next

A useful first slice.
A visible roadmap.

Baz supports native Windows x64, Linux, and macOS. All three have passed Debug/ReleaseSafe verification, package checks, all 20 ported-example groups, and all 14 streaming groups. Windows also passed shard-handoff and console-shutdown cases. Baz remains experimental; these are correctness gates, not production qualification.

The framework reserves its own storage at startup. Application code and the caller’s I/O provider have separate resource responsibilities. Fixed workers do not provide arbitrary application isolation.

09 / Read further

From first route
to the ownership details.

Guides stay as Markdown in the repository. The browser reader adds a table of contents, highlighted source, raw-file access, and print support.