One TodoMVC, nine languages, one platform

We built the same small app nine times, once in each of nine language setups, and put every one on Carloku, the hosted CARLOS Platform. The app is TodoMVC: a to-do list. Here it's a page the server builds, which works with JavaScript switched off, plus a little JavaScript on top so it feels like the familiar TodoMVC.

The point is to show that CARLOS apps, and the platform they run on, aren't tied to Go. So this page compares the nine; it doesn't rank them.

One AI model, Opus 5.5, built every app from the same brief. A second, Astra, reviewed each one. A third, Fable, scored how readable the code is without being told which app it was reading. All nine apps are live, and their code is public at amadan.net/carlos/todomvc-bakeoff.

Read the write-up: what the numbers mean and what we conclude

What stood out

All nine pass every shared test on Carloku: 67 of 67, with JavaScript on and with it off.
Nim and Zig handled the most traffic on Carloku's default size: about 1,400 to 1,500 page loads a second, and 3,100 to 3,600 toggles. They also made the smallest programs (under 2 MB) and used the least memory at rest (2.5 to 3.5 MB).
Go builds fastest. About 10 seconds from scratch and under a second to rebuild, with or without Rastrillo.
Waking up costs about the same everywhere. Every app answered its first request after sleeping in 1.2 to 1.5 seconds; about one second of that is Carloku starting the program.
Build costs ranged from $2.92 to $10.70. Rust was the cheapest. Spinel was the most expensive, mostly because getting it to compile for ARM took the builder 77 minutes.
Spinel restarted under heavy load. Its server process exited 16 times during the load test, and Carloku started it again each time. In one 10-second step, no request completed at all.

At a glance

Setup	Tests (JS on · off)	First byte	Wake	Peak reads/s	Binary	Cold build / one-line change	Lines	Deps	Cost	Readability
Go	35/35 · 32/32	95.9 ms	1267 ms	349	12.3 MB	10.3 s / 0.1 s	880	1	$3.69	8/10
Go + Rastrillo	35/35 · 32/32	56.6 ms	1369 ms	336	14.1 MB	10.4 s / 0.1 s	797	3	$4.67	8/10
Rust	35/35 · 32/32	93.2 ms	1245 ms	904	3.2 MB	49.6 s / 5.8 s	815	7	$2.92	8/10
Zig	35/35 · 32/32	50.2 ms	1238 ms	1,382	1.9 MB	2.5 min / 5.4 s	1058	1	$5.71	9/10
OCaml	35/35 · 32/32	51.7 ms	1286 ms	992	8.2 MB	18.3 min / 3.3 s	697	9	$7.65	8/10
Haskell	35/35 · 32/32	99.3 ms	1364 ms	400	28.7 MB	19.1 min / 26.6 s	798	10	$5.06	8/10
Swift	35/35 · 32/32	58.7 ms	1445 ms	537	22.0 MB	81.4 s / 3.9 s	725	3	$4.60	8/10
Nim	35/35 · 32/32	50.6 ms	1299 ms	1,491	1.8 MB	33.9 s / 0.9 s	1006	2	$4.84	8/10
Spinel	35/35 · 32/32	94.6 ms	1285 ms	722	8.7 MB	4.8 min / 104.0 s	566	2	$10.70	7/10

Time to first byte, empty list

Median of 30 page loads from our test machine, each on a new connection, so it includes the network.

Time to first byte, 50 items

The same, with 50 todos on the list.

Wake from sleep

Time to the first byte when the app had gone to sleep after 15 idle minutes. Median of three.

Peak page loads per second

Loading a 50-item list, starting with one connection and doubling the number of simultaneous connections every 10 seconds.

Page loads: where it slows down

The fewest simultaneous connections from which adding more never raised throughput by 10% or more.

Peak toggles per second

Ticking one todo on and off, ramping the same way.

Toggles: where it slows down

The same rule as for page loads.

Peak page loads per second, after the writes

The read ramp again, straight after the toggle ramp, on the same database.

Page loads after the writes: where it slows down

The same rule, for the read ramp run straight after the writes.

Memory at rest

Resident memory just after start, measured on our own machine because Carloku doesn't show members memory figures.

Memory under load

The most resident memory each app used during 10 seconds of 64 simultaneous page loads and then 10 seconds of 64 simultaneous toggles, on our own machine.

Binary size

The linux-arm64 file that ships.

Cold build

Every library compiled from already-downloaded sources. One run each, because some take close to an hour under emulation.

Rebuild after a one-line change

Everything already compiled, then one line added to the code that serves the page (a unique comment, so no cache can skip the work). Median of three.

Lines of code

Non-blank lines of each app's own code. Tests are not counted.

server
templates
JavaScript

Setup	server	templates	JavaScript
Go	665	83	132
Go + Rastrillo	609	102	86
Rust	702	0	113
Zig	964	0	94
OCaml	597	0	100
Haskell	685	0	113
Swift	650	0	75
Nim	819	75	112
Spinel	495	0	71

Cost to build

What Opus 5.5 cost at list price for the build and its fix rounds.

Tokens written to build

Output tokens Opus 5.5 produced for the build and its fix rounds.

Readability

A blind score out of 10 from Fable, a different model from the builder. Median of three readings.

The apps

Go

Live app

https://todo-go-2.bfj.oncarlos.com

Source

https://amadan.net/carlos/todomvc-bakeoff?ref=main&path=apps/go

Stack

Go's standard web server and templates, with SQLite through modernc.org/sqlite (pure Go).

Readability

Strongest: comments consistently explain why (migration policy, single-writer pool, Origin check, focusout during swap), and the package docs state the security model up front. Request flow is short: route in New -> itemAction -> action -> Store method -> render "list". Error path is explicit via ErrNotFound and fail, with buffered rendering for clean 500s. Weakest: action/itemAction wrappers with inline closures and two differing callback signatures add a layer to step through; `one`, `w`/`r` fields and `bumpMarker` are terse or odd. loadStatic ignores fs.Sub and WalkDir errors, and the view struct mixes filter state, counts and Version. app.js swap/draft restoration is dense.

Left after review

[spec] [apps/go/main.go:114](/home/paulca/amadan.net/carlos/todomvc-bakeoff/.worktrees/go/apps/go/main.go:114): `checkLoopback` accepts any loopback address, including `127.0.0.2` and `::1`. The brief explicitly requires binding only to `127.0.0.1`. These alternative `--listen` addresses pass validation and start a listener; restrict validation to the required address.

Go + Rastrillo

Live app

https://todo-go-rastrillo-2.bfj.oncarlos.com

Source

https://amadan.net/carlos/todomvc-bakeoff?ref=main&path=apps/go-rastrillo

Stack

Rastrillo 0.28, the CARLOS web framework: chi for routing and GORM over SQLite.

Readability

Strongest: a toggle is traceable in seconds — Router lists every route, owned() is the single ownership seam, afterItemWrite maps error/no-row/success to 500/404/done, and done() explains the 303-vs-fragment split. Comments consistently explain why (Resolve not Run, why not csrf.Protect, parseForm's 1 MiB cap, toggleAll's single-statement race note). Weakest: renderStatus swallows template errors with a bare http.Error and no log or ref, unlike fail(); several `uid, _ := sessions.UserID(r)` rely on an invariant stated only in visitor.go; repeated 'the contract' references assume context the reader lacks; done() is a vague name for 'respond after success'. app.go mixes wiring with parseForm middleware.

Left after review

[correctness] `apps/go-rastrillo/internal/todo/static/app.js:42` — Every action response replaces the entire app, preserving only the new-todo input. With a request pending, double-click another todo and start editing: when the earlier response arrives, the editor disappears and its unsaved text is lost. Preserve the active editor’s value and focus across replacement, or defer replacement until editing finishes.

Rust

Live app

https://todo-rust-2.bfj.oncarlos.com

Source

https://amadan.net/carlos/todomvc-bakeoff?ref=main&path=apps/rust

Stack

axum on tokio, Maud for HTML, and rusqlite with SQLite built in.

Readability

Strongest: the `act` helper gives every action one pipeline (resolve visitor, transaction, 404/303/fragment), so a request is easy to follow from route to db to markup; comments explain real why (body-read before 403 behind the edge, mutex over a pool, append-only migrations, editing li preservation). db.rs is one query per function with scoped list ids. Weakest: handler params are single letters (s, h, q, f) and the `found`/`Outcome` indirection adds a hop; `swap` in app.js is dense DOM surgery that needs careful reading; errors are only rusqlite wrapped in AppError and logged with eprintln, with a few `expect`s standing in for proper failure paths.

Left after review

[correctness] [apps/rust/static/app.js:10](/home/paulca/amadan.net/carlos/todomvc-bakeoff/.worktrees/rust/apps/rust/static/app.js:10): Filter navigation can discard pending changes. Requests wait in a promise queue, but filter links navigate immediately. With a toggle request pending, edit another todo and click a filter: blur queues the save, then navigation destroys the queue before that save reaches the server. Wait for pending actions before navigating.
[spec] [apps/rust/src/main.rs:45](/home/paulca/amadan.net/carlos/todomvc-bakeoff/.worktrees/rust/apps/rust/src/main.rs:45): `--listen` accepts every loopback address, including `::1` and `127.0.0.2`. The brief explicitly restricts binding to `127.0.0.1`. Validate that exact address.

Zig

Live app: https://todo-zig-2.bfj.oncarlos.com
Source: https://amadan.net/carlos/todomvc-bakeoff?ref=main&path=apps/zig
Stack: Zig's standard-library HTTP server, with SQLite 3.54 compiled in.
Readability: Strongest: a request is trivially traceable (app.js form → handle → post → itemAction → Store.toggle → page/303), helped by the Response/Visitor/Form structs and tight module split. Comments earn their place: why headers are copied before reading the body, why keep-alive drops after an oversized body, why a single mutexed SQLite connection. Tests double as documentation. Weakest: errors in db.zig collapse to one opaque error.Sqlite with logging as the only detail; readerExpectContinue's failure is remapped to WriteFailed, hiding the cause; post() mixes routing and handling in one long if-chain, and get() parses the query inline. Minor: static() and run() names are terse.

OCaml

Live app

https://todo-ocaml-2.bfj.oncarlos.com

Source

https://amadan.net/carlos/todomvc-bakeoff?ref=main&path=apps/ocaml

Stack

OCaml 5 with Eio and cohttp-eio, and sqlite3-ocaml over SQLite 3.54.

Readability

Strongest: a toggle is trivially traceable (handle → action_of_path → post → perform → Store.toggle → View.fragment or 303), helped by App being server-independent and each module having one clear job. Comments are nearly all 'why' (Budget rationale, cookie age, migration rule, CSP hash, JS render invariants) with no noise. Weakest: handle's `filter p <> None ... Option.get (filter p)` double evaluation is clunky and hides intent; Store errors surface only as failwith exceptions caught by run_server's generic logger, and user_version's exec result is ignored; main.ml's Budget/connection plumbing and nested try blocks take effort to follow; a few terse names (change, shows, done_, go) need a moment.

Left after review

[correctness] `apps/ocaml/static/app.js:14` — Filter navigation can discard queued edits. With a toggle request pending, edit another item and click “Active”: blur queues the save, but the ordinary filter link immediately unloads the page before that save runs. The changed title is lost. Wait for pending mutations before navigating between filters.

Haskell

Live app: https://todo-haskell-2.bfj.oncarlos.com
Source: https://amadan.net/carlos/todomvc-bakeoff?ref=main&path=apps/haskell
Stack: warp and WAI, Lucid for HTML, and sqlite-simple.
Readability: Strongest: tracing a request is effortless. The toggle route goes from the pathInfo case through the `post` helper to Db.toggleTodo and back to Html.fragment, with the Bool-means-found contract stated at each end. Comments consistently explain why (WAL via query_, getrandom over /dev, single connection, the `swapping` flag) without restating code. Weakest: error handling is mostly implicit. Database exceptions reach Warp's default 500 with no logging; migrate silently assumes version 0 on an odd PRAGMA result; the getrandom loop retries on any negative result, not only EINTR; app.js hides every failure behind location.reload(). Minor: `app`'s where-block is long and the multiway-if in `post` is dense; `common`, `with`, `f`, `v` are terse names.

Swift

Live app

https://todo-swift-2.bfj.oncarlos.com

Source

https://amadan.net/carlos/todomvc-bakeoff?ref=main&path=apps/swift

Stack

Hummingbird 2 on SwiftNIO, with SQLiteNIO.

Readability

Strongest: traceability and comments. Toggling an item reads straight through: route in Routes.register, the shared `action` helper, Store.toggle's single RETURNING statement, then Page.body or a 303. Doc comments explain real decisions (one SQLite connection serialising writes, append-only migrations, 400-day cookie, nojs controls, the JS action queue) with almost no noise. Weakest: a few quiet fallbacks. Store.todos maps missing columns to 0/""/false instead of failing; app.js turns every failed action into a silent page reload; Assets is referenced but its definition (generated) isn't here, and Static.swift is an odd home for one helper. Helper names `action` and `changed` are generic, and the two trimmingWhitespace extensions live in unrelated files.

Left after review

[correctness] [apps/swift/static/app.js:32](/home/paulca/amadan.net/carlos/todomvc-bakeoff/.worktrees/swift/apps/swift/static/app.js:32): Every action response removes the entire list, including any active editor. Toggle one item, then start editing another before the response arrives: the replacement discards the draft and focus without saving. Serializing requests does not protect unsent edits. Preserve active editor contents and focus across updates, or defer replacement until editing finishes.

Nim

Live app

https://todo-nim-2.bfj.oncarlos.com

Source

https://amadan.net/carlos/todomvc-bakeoff?ref=main&path=apps/nim

Stack

Nim's standard-library async HTTP server (a patched copy, to serve a Unix socket and cap request bodies), with SQLite through db_connector.

Readability

Strongest: comments explain non-obvious decisions (maxBody sizing, trimTitle UTF-8 defect, chunked-body fix flagged in the vendored server, JS request queue and rendering flag) without noise; store.nim's prepared-statement enum plus bound/exec/count keeps SQL in one readable table; app.nim is cleanly sectioned. Weakest: `action` hand-parses path segments with len checks and a `found` flag, so the per-item verbs are harder to scan than a dispatch table would be; the `var r: Reply` side-channel for Set-Cookie headers in `listFor` is indirect; many `discard reset/finalize/close` and a stray `# make bump` comment sitting above the wrong constant. The vendored httpserver.nim is large but well-marked.

Left after review

[correctness] `apps/nim/src/store.nim:181` — `$column_text(st, 1)` reads a NUL-terminated C string, although titles are stored with an explicit byte length. Posting `title=before%00after` therefore displays only `before`; saving that edit permanently loses the suffix. Read the value using `column_bytes` so accepted Unicode titles survive retrieval intact.

Spinel

Live app

https://todo-spinel-4.bfj.oncarlos.com

Source

https://amadan.net/carlos/todomvc-bakeoff?ref=main&path=apps/spinel

Stack

tep, a Sinatra-style layer, compiled to a native program by Spinel, with SQLite 3.50 compiled in.

Readability

Strongest: traceability. Each route reads top to bottom: origin check, visitor, path_id, todo_exists, one inline SQL statement, finish_post, render_lists. Comments explain the non-obvious (Spinel subset, single-cursor shim, token-issuance check, BUILD_NOTE). Weakest: errors. Write paths (run_sql, add_todo, rename_todo, record_token) discard DB.step's result, so a failed INSERT or UPDATE silently returns a stale fragment; the JS catch-all reload hides failures too. Lesser points: parallel arrays with a `done` field of ints, generic run_sql with a magic `id > 0` bind rule, layout/page/path_id filed under the Actions divider, and unexplained constants (18 and 19 character limits).

Left after review

[correctness] `apps/spinel/app.rb:475` and `:527` — `strip` only removes ASCII whitespace. A title containing only U+00A0 or U+2003 creates a blank-looking todo, and editing to that value does not delete it. Apply Unicode whitespace trimming before the empty-title check.
[correctness] `apps/spinel/patches/2-tep-bakeoff.patch:330` — URL decoding turns `%00` into a NUL inside a C string, which is then truncated when copied into Ruby. Posting `title=before%00after` silently stores `before`; editing with `title=%00after` deletes the todo. Preserve decoded string lengths so input cannot silently become a different title or action.
[spec] `apps/spinel/Makefile:130` — `clean-deps` deletes only the local SQLite and tep artifacts. The arm64 build still links precompiled OpenSSL, zlib and zstd libraries from the shared toolchain root (`scripts/arm64-cc:21`), so the next build does not compile every third-party library from scratch as required. Build those dependencies into the app’s own cache and include them in `clean-deps`.

Note

Its server process exited 16 times during the load test, and Carloku started it again each time. Requests that arrived meanwhile got an error.

How we measured

The same starting point. Every builder got the same brief, the same rules for routes and forms, TodoMVC's own page and styles, and the same tests. It chose its own libraries.
The same tests. TodoMVC's 29 standard tests, run with JavaScript on and again with it off, plus checks for unsafe input, foreign characters, very long titles, one visitor reaching another's list, and a screenshot comparison with TodoMVC's own page.
One build each. Opus 5.5 built each app in a single unattended session, with a four-hour limit.
One round of review. Astra reviewed each app for bugs, missed requirements and security problems, and the same builder fixed what it found. A second round was allowed only for security problems; Zig and Nim needed one.
Readability. Fable scored each app's code out of 10 three times, without knowing which app it was. We show the median.
Speed. Measured from one test machine over the internet, one app at a time, each on a fresh copy of the app with an empty database. Time to first byte is the median of 30 page loads. The load test doubles the number of simultaneous connections from 1 upwards, 10 seconds per step, first loading a 50-item list, then ticking a to-do on and off, then loading the list again.
Waking up. Carloku puts an app to sleep after 15 quiet minutes. We timed the first request after each app fell asleep, three times.
Builds. Every app is built for the 64-bit ARM servers Carloku runs on. A cold build compiles every library from scratch, once per app. A one-line change rebuilds after adding one line to the code that serves the page, with everything else already compiled; it's the median of three.
Cost. What each build and its fixes cost at list price, from the builders' own session records.

What this does and doesn't show

The network is in every speed number. Requests travelled from our test machine to Carloku over the internet, and the base delay swung between about 17 and 37 milliseconds during the runs. Small differences in first-byte times mean little.
Carloku caps traffic at the edge. When a request reaches an edge server that isn't the one running the app, Carloku lets at most 64 such requests be in flight at once and turns the rest away with a "try again shortly" response. Above 64 connections, the load test partly measures that limit, and whether it applied depended on how our traffic was routed at the time.
Some apps failed outright at very high load. At 256 or 512 connections, Swift, Nim and Spinel stopped answering some requests, which Carloku's edge reported as errors (502) rather than turning them away. The charts mark where that started.
Every app ran on Carloku's default size. Throughput limits reflect that size, not what each language could do on a bigger server.
One build per language. Another session with the same model could produce a different app, faster or slower.
Readability scores cluster. Most apps scored 8 out of 10. Treat the score as a rough signal.
Three apps were built under emulation. OCaml, Haskell and Spinel had no straightforward way to compile for ARM from our x86 machine, so they were built inside an emulated ARM system. Their build times are much longer for that reason, and don't compare with the others.
Spinel restarted under heavy load. Its server process exited during the load test and Carloku started it again each time.
Mojo was dropped. Mojo can't produce a single self-contained program file, which is what Carloku runs, so we replaced it with Nim. The platform question is filed as an idea.
Fresh copies for measuring. To give every app an empty database, each was measured on a new copy of itself, which is the one the live links point to.