---
title: "Fortran Web Server on a $12 Droplet: How It Beat Python (1.7x, Not 2x)"
date: "2026-10-16"
video_id: "7697383263530274061"
tiktok_url: "https://www.tiktok.com/@arjay_mccandless/video/7697383263530274061"
creator: "@arjay_mccandless"
category: "Coding"
tags: ["fortran", "libmicrohttpd", "sqlite", "web server benchmark", "twelve dollar server challenge"]
excerpt: "A Fortran entry in the $12 server challenge held 1.7x the users of the best Python entry. Its HTTP layer is GNU libmicrohttpd in C, and it was not the winner."
---
A Fortran web API held 38,000 concurrent users on a $12 DigitalOcean droplet in Arjay McCandless's server challenge, 1.7x the best Python entry's 22,000 by his own graphic. His TikTok narration rounds that to "twice as many." The HTTP server underneath is GNU libmicrohttpd, a C library, which the challenge rules allow, and Fortran was not the top entry overall.

## What is the $12 server challenge?

The [twelve-dollar-server-challenge](https://github.com/arjaythedev/twelve-dollar-server-challenge) repository asks developers to build an API that holds as many concurrent users as possible on one box: "a DigitalOcean Basic droplet: 1 vCPU, 2 GB RAM, no swap" running Ubuntu 24.04, with SQLite as the database. [DigitalOcean's pricing](https://www.digitalocean.com/pricing/droplets) lists that plan at $12 a month.

To pass, an entry must hold a 5-minute load with p95 latency under 500 ms, p99 under 1 s and errors under 1%. Rule 1 allows "Any language, framework, runtime and SQLite driver/binding."

## Did the Fortran entry really hold twice as many users as Python?

No, 1.73x. The narration says "it held twice as many users as our best Python submission," while the on-screen card reads "1.7x users held, same test, same server." The closing leaderboard shows Fortran at 38,000, C# at 32,000, Python at 22,000 and Go at 22,000.

Those per-language figures appear only in the creator's graphics. The repository holds no results file. They come from his YouTube video, [I Asked Expert Programmers to Max Out a $12 Server](https://www.youtube.com/watch?v=QGWKCaglSBI), uploaded 2026-10-13, whose description says "you got it to 64,000 concurrent users. Same 1 vCPU / 2 GB box where my best result last video was 14,050." His [earlier video](https://www.youtube.com/watch?v=sQXFhh_PiG4) benchmarked eight languages on Postgres.

## Was Fortran the fastest language in the challenge?

No. The top result was 64,000 users, so at least one entry held 1.68x what Fortran did. Three rows above Fortran are greyed out in the TikTok's leaderboard, and the YouTube chapters place Fortran sixth of twelve languages. The TikTok's own caption says "Is Fortran faster than Python? Not really, but it did well here!"

A community rerun tells a different story. In [issue #7](https://github.com/arjaythedev/twelve-dollar-server-challenge/issues/7), participant XXMOHAMED012 ran 27 entries under the README's scoring protocol on one Intel i5-13600KF E-core with 2 GiB RAM over loopback. The Fortran entry held 54,500 users at 5,768 requests per second and placed 21st, limited by memory at a 1,987 MiB peak. The two Python FastAPI entries held 57,500 and 62,000, and the two C# entries 65,250 each. The author notes "An E-core over loopback is not the droplet," so the ranking depends on which resource runs out first.

## Is the Fortran server really written in Fortran?

Partly. The video says the HTTP server "isn't actually written in Fortran. It's handled by libmicrohttpd, a web server library from GNU written in C, plus a small C bridge." The [entry's folder](https://github.com/arjaythedev/twelve-dollar-server-challenge/tree/main/submissions/fortran-microhttpd-tbsvttr) confirms it. The libmicrohttpd README describes it as "a GNU package offering a C library that provides a compact API and implementation of an HTTP 1.1 web server."

The entry pins libmicrohttpd 1.0.2, released 2025-07-14, which the build script downloads from [mirrors.kernel.org](https://mirrors.kernel.org/gnu/libmicrohttpd/libmicrohttpd-1.0.2.tar.gz) and checks by SHA-256. The [GNU release directory](https://ftp.gnu.org/gnu/libmicrohttpd/) shows newer versions through 1.0.10 on 2026-08-07. The challenge requires pinned dependency versions, so the older pin is deliberate.

The code is exactly 750 lines, as the video says. `server.f90` has 311, `bindings.f90` 146, `unicode.f90` 118 and `bridge.c` 175, which is 575 Fortran lines and 175 C lines. The submitter's README says "This is not an implementation written exclusively in Fortran."

The presenter calls the C layer "kind of cheating," but rule 1 allows it, and other top entries did the same. The C++ entry, for example, runs on uWebSockets.

## What does the Fortran code handle?

[Pull request #16](https://github.com/arjaythedev/twelve-dollar-server-challenge/pull/16), by GitHub user `tbsvttr`, says "Fortran owns routing, SQL, JWT claims, Unicode, JSON and transaction policy; a counted C bridge supplies the HTTP/crypto/SQLite ABI adapters." The `dispatch` subroutine in `server.f90` routes `/posts` and `/feed`.

The video says "checking a login token is just one SQL query." The claims check is one query using SQLite's `json_extract` and `json_type`. The signature check runs in C: `bridge.c` computes an HMAC-SHA256 with [fio-stl](https://github.com/facil-io/cstl), the MIT-licensed facil.io C library. A login check is one SQL query plus HMAC in C.

## How does it use SQLite for JSON?

Literally. `server.f90` prepares `SELECT json_extract(?1,'$.body'),json_type(?1,'$.body')` to parse request bodies. SQLite's [JSON functions](https://sqlite.org/json1.html) have been built in by default since 3.38.0. The entry pins SQLite 3.53.4, released 2026-07-24 according to the [SQLite changelog](https://sqlite.org/changes.html).

## How does the Fortran entry batch database writes?

The video says "every write that came in during a single pass of the event loop shared one database commit." The C bridge runs `MHD_run_wait(daemon, 100)` and then `app_flush()`. Requests waiting on an open transaction are suspended, Fortran commits once the event-loop pass ends, and the bridge resumes those connections with their responses.

Rule 6 allows this: "Batching several requests' writes into one transaction (group commit) is allowed if each response waits for its commit." The entry also caps accepted connections at 65,000 and shrinks libmicrohttpd's per-connection memory pool from 32 KiB to 16 KiB.

## Is Fortran really from 1957?

Yes. [IBM's history page](https://www.ibm.com/history/fortran) says "In 1957, the IBM Mathematical Formula Translating System, or Fortran, debuted." That is 69 years before 2026.

Pull request #16 shows as "open" in the video, but GitHub records it merged at 21:33 UTC on 2026-10-16, about five minutes before the TikTok posted.

## Bottom line

A Fortran entry with a C HTTP layer held 1.7x the best Python entry on the creator's droplet, using SQLite for JSON and one commit per event-loop pass. It finished mid-table, and on different hardware it ranked 21st of 27, behind both Python FastAPI entries.

## Sources

- [twelve-dollar-server-challenge on GitHub](https://github.com/arjaythedev/twelve-dollar-server-challenge) - rules, droplet spec and scoring
- [Pull request #16](https://github.com/arjaythedev/twelve-dollar-server-challenge/pull/16) - the Fortran submission
- [Fortran submission folder](https://github.com/arjaythedev/twelve-dollar-server-challenge/tree/main/submissions/fortran-microhttpd-tbsvttr) - source files and README
- [Issue #7](https://github.com/arjaythedev/twelve-dollar-server-challenge/issues/7) - community rerun of 27 entries
- [I Asked Expert Programmers to Max Out a $12 Server](https://www.youtube.com/watch?v=QGWKCaglSBI) - the creator's results video
- [Which Programming Language Can Handle the Most Users on a $12 Server?](https://www.youtube.com/watch?v=sQXFhh_PiG4) - the first challenge video
- [GNU libmicrohttpd releases](https://ftp.gnu.org/gnu/libmicrohttpd/) - release dates
- [libmicrohttpd 1.0.2 tarball](https://mirrors.kernel.org/gnu/libmicrohttpd/libmicrohttpd-1.0.2.tar.gz) - the pinned version
- [SQLite release history](https://sqlite.org/changes.html) - SQLite 3.53.4 date
- [SQLite JSON functions](https://sqlite.org/json1.html) - json_extract and json_type
- [facil-io/cstl](https://github.com/facil-io/cstl) - the C library used for HMAC
- [DigitalOcean Droplet pricing](https://www.digitalocean.com/pricing/droplets) - the $12 plan
- [IBM: Fortran](https://www.ibm.com/history/fortran) - 1957 debut
- [Dennis Ritchie, The Development of the C Language](https://www.nokia.com/bell-labs/about/dennis-m-ritchie/chist.html) - C history
- [Python General FAQ](https://docs.python.org/3/faq/general.html) - Python's 1991 release
- [Google Open Source Blog on Go](https://opensource.googleblog.com/2009/11/hey-ho-lets-go.html) - Go announcement
- [Announcing Rust 1.0](https://blog.rust-lang.org/2015/05/15/Rust-1.0/) - Rust 1.0 release


## Video description and verification notes

**The narration says the Fortran entry "held twice as many users as our best Python submission," while the card on screen during that sentence reads "1.7x users held, same test, same server," and the closing leaderboard puts Fortran at 38,000 users against Python's 22,000, which is 1.73x. The artifact is a 58.19-second vertical clip, 1080x1920 at 30 fps, HEVC tagged `hvc1` at 620,744 bps across 1,745 frames, with AAC stereo audio at 44,100 Hz and 48,153 bps, 4,913,258 bytes on disk. TikTok's metadata stamps the post at 2026-10-16 21:38:46 UTC from uploader `arjay_mccandless`, channel "Arjay McCandless," with the description "Is Fortran faster than Python? Not really, but it did well here! #coding #programming". At capture on 2026-10-19 the counters read 57,500 views, 4,841 likes, 72 comments, 128 reposts, and 721 saves. I read all 29 extracted frames and all 211 transcript words across 22 Whisper segments; the audio runs 58.25 seconds and the last segment ends at 58.10, so I discarded nothing. Twelve frames are full-screen motion graphics on an off-white background, three (9, 15, 23) show only the presenter, a dark-haired man in a navy t-shirt at a laptop in front of a window with red flowers, holding a lavalier mic, and fourteen split horizontally with graphics above him. Frames 1 and 2 draw a DigitalOcean "1 droplet" card (1 vCPU, 2 GB RAM, Ubuntu 24.04, a "$12/mo" sticker) over a "PASS RULE" strip: "p95 < 500 ms," "p99 < 1 s," "errors < 1 %," "5-minute hold." Frame 3 shows an IBM punch card with FORTRAN punched in columns 7 to 13 beside a "PR #16 open" badge. Frames 5 and 6 run a timeline: a greyed "1956" that resolves to "1957 FORTRAN I," then "C 1972," "Python 1991," a Java row hidden behind the caption, "Go 2009," "Rust 2015," "2026 today," and "69 years." Frame 7 shows a Fortran stencil loop over a heat map marked "iter 112" and the expansion "FORmula TRANslation"; frame 8 is a "Navier-Stokes solver, vortex street" flow plot. Frame 10 names the repo folder `fortran-microhttpd-tbsvttr` and tags the C++ and Ruby "top entry" cards with the same "trick ?" badge. Frame 13 lists "libmicrohttpd v1.0.2 embedded HTTP server" with six handles: epoll event loop, HTTP/1.1 parsing, keep-alive, chunked uploads, backpressure, suspend / resume. Frame 16 shows four files (`server.f90`, `bindings.f90`, `unicode.f90`, `bridge.c`) over "750 lines of app code." Frames 17 and 18 show a `dispatch` subroutine routing `/posts` and `/feed` with an `INSERT INTO posts ... RETURNING id,created_at`. Frame 20 lists dependencies "libmicrohttpd v1.0.2 · HTTP" and "fio-stl HMAC · base64." Frame 21 shows "SQLite v3.53.4" and the line `body_query=prepare("SELECT json_extract(?1,'$.body'), json_type(?1,'$.body')")`. Frame 22 shows a bearer token beginning `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9` with payload `{"sub":"42","username":"...","exp":...}`. Frame 23's burned-in caption misspells writes as "RIGHTS." Frames 24 and 25 animate "ONE PASS OF THE EVENT LOOP" from "writes 3, commits 0" to "writes 7, commits 1" over the lines `if (MHD_run_wait(daemon, 100) != MHD_YES) break;` and `int ok = app_flush();`. Frame 26 shows `MHD_resume_connection(r->connection);` above six "201 Created" rows. Frame 27 is a "Fortran PR #16 RESULT" card: 38,000 users, 3,532 req/s. Frames 28 and 29 show "BEST ENTRY PER LANGUAGE" with three greyed rows marked "?", then Fortran 38,000, C# 32,000, Python 22,000, Go 22,000.**

## The video's own card says 1.7x; the narration says twice

The transcript from 3.92 to 7.74 seconds reads: "Somebody did it in Fortran, and it held twice as many users as our best Python submission." Frame 4, on screen during that sentence, reads "1.7x users held, same test, same server." Frame 29 gives the inputs: Fortran 38,000, Python 22,000. The ratio is 1.727. The graphic is right and the voiceover rounds it up by about 16 percent. I am correcting the narration to the video's own number.

Those figures are the creator's and I could not check them against anything outside his graphics. The challenge repository, [arjaythedev/twelve-dollar-server-challenge](https://github.com/arjaythedev/twelve-dollar-server-challenge), holds no results file. Its root contains `README.md`, `SPEC.md`, `schema.sql`, `LICENSE`, and the folders `bench/`, `seed/`, `test/`, and `submissions/`, and the README says merged entries wait "for the next benchmark batch" with results shared "once a batch is done." The results live in a 22-minute, 56-second YouTube video, [I Asked Expert Programmers to Max Out a $12 Server](https://www.youtube.com/watch?v=QGWKCaglSBI), uploaded 2026-10-13 and at 582,065 views when I pulled its metadata with yt-dlp. Its description reads: "I challenged you to max out a $12 server, and you got it to 64,000 concurrent users. Same 1 vCPU / 2 GB box where my best result last video was 14,050." Its chapters run Ruby, Erlang, Python, Go, C#, Fortran, PHP, C, Bun, Rust, Zig, C++. YouTube refused the auto-captions to my client (it now requires a PO token), so I could not pull the per-language numbers out of the creator's spoken words. The 38,000, 32,000, 22,000, and 22,000 on screen are his figures and I label them unverified. The 64,000 at the top of the table is confirmed by his description.

## The HTTP server is GNU libmicrohttpd 1.0.2, a C library, and the rules allow it

The video says the HTTP server "isn't actually written in Fortran. It's handled by libmicrohttpd, a web server library from GNU written in C, plus a small C bridge." Every part of that checks out against the release tarball. The submission's `build.sh` downloads `libmicrohttpd-1.0.2.tar.gz` from mirrors.kernel.org and refuses to build unless its SHA-256 is `df324fcd0834175dab07483133902d9774a605bfa298025f69883288fd20a8c7`. I downloaded the same file and got the same hash. Its README opens: "GNU libmicrohttpd is a GNU package offering a C library that provides a compact API and implementation of an HTTP 1.1 web server." Its ChangeLog dates the 1.0.2 release to 14 July 2025, `src/include/microhttpd.h` defines `MHD_VERSION 0x01000200`, the library is dual-licensed LGPLv2.1+ and eCos, and `src/microhttpd/` holds 56 C files.

The six "handles" in frame 13 map to real API. The 1.0.2 header declares `MHD_run_wait` at line 3410, `MHD_suspend_connection` at line 3786 ("Suspend handling of network data for a given connection. This can be used to dequeue a connection from MHD's event loop"), and `MHD_resume_connection` at line 3804, and sets `MHD_USE_EPOLL = 512`. The submission's `bridge.c` calls all four, and starts the daemon with `MHD_OPTION_CONNECTION_LIMIT`, `MHD_OPTION_CONNECTION_MEMORY_LIMIT`, and `MHD_OPTION_CONNECTION_TIMEOUT`.

Frame 13's "v1.0.2" is accurate for the entry and stale for the project. The [GNU FTP listing](https://ftp.gnu.org/gnu/libmicrohttpd/) shows 1.0.2 dated 2025-07-14 and eight later releases through 1.0.10 on 2026-08-07. The pin is deliberate: rule 10 of the challenge requires pinned dependency versions built from source on the box.

"This is kind of cheating" is the presenter's judgment, and the rules he wrote disagree with him. Rule 1 reads: "Any language, framework, runtime and SQLite driver/binding. Any number of processes or threads." The submitter says the same thing in the entry's README: "This is not an implementation written exclusively in Fortran." Frame 10 tags the C++ and Ruby top entries with the same "trick ?" badge, and the entry's own comparison table shows the C++ entry running on uWebSockets, another C/C++ server library. Letting a C library own the sockets was the common pattern, as the transcript says at 16.96 seconds.

## 750 lines is exact: 575 Fortran and 175 C, and the C does the cryptography

Frame 16's "750 lines of app code" matches the entry to the line. I fetched the four source files from the merged `main` branch and counted: `server.f90` 311 lines, `bindings.f90` 146, `unicode.f90` 118, and `bridge.c` 175, total 750. The submission README states the split: "575 Fortran lines plus 175 C lines, 750 total, including comments and blanks."

The video says "the routing, database logic, and JSON generation are all still in Fortran," and the submitter's PR description agrees: "Fortran owns routing, SQL, JWT claims, Unicode, JSON and transaction policy; a counted C bridge supplies the HTTP/crypto/SQLite ABI adapters." `server.f90` line 102 declares `subroutine dispatch(method,path,auth,input,status,out)`, lines 126 and 127 set `create_route=submit.and.path=='/posts'` and `feed_route=get.and.path=='/feed'`, and line 246 exposes `app_flush()` with `bind(C)`. The code in frames 17 and 18 is the real file.

The word "crypto" in that PR description is what the narration drops when it says "checking a login token is just one SQL query." The claims check is one SQL statement: `server.f90` lines 291 to 295 build `auth_query` from `json_extract(?2,'$.exp')`, `json_extract(?2,'$.nbf')`, a test that `json_extract(?1,'$.alg')='HS256'`, and `json_type` checks that `sub` and `username` are text. The signature check is C. `bridge.c` defines `FIO_STR` and `FIO_SHA2`, includes `fio-stl.h`, base64-decodes the signature with `fio_string_write_base64dec`, computes `fio_sha256_hmac(secret, ..., message, ...)`, and compares with `fio_ct_is_eq`. A login check is one SQL query plus an HMAC-SHA256 in C. The second dependency on frame 20, "fio-stl HMAC · base64," is the facil.io C STL at [facil-io/cstl](https://github.com/facil-io/cstl), MIT-licensed, which the entry pins to commit `24a57015d0989c64d5cc08ea9d24bd6cf97848bb` with its own SHA-256; the repository's module list includes `152 sha2.h` and `201 string.h`.

The bearer token in frame 22 is a real HS256 header. Base64-decoding `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9` yields `{"alg":"HS256","typ":"JWT"}`, and the visible start of the second segment decodes to `{"sub":"42","username":"`. The challenge's test suite rejects `alg=none`, bad signatures, expired tokens, and non-integer `sub` values, and the entry's `validation-results.json` lists each of those cases as passing.

## SQLite 3.53.4 as the JSON parser, and group commit is written into rule 6

"They used SQLite as their JSON parser" is literal. `server.f90` line 290 reads `body_query=prepare("SELECT json_extract(?1,'$.body'),json_type(?1,'$.body')")`, the line frame 21 shows. SQLite's [JSON documentation](https://sqlite.org/json1.html) defines `json_extract(X,P1,P2,...)` and `json_type(X,P)` and notes the functions have been built in by default since 3.38.0 (2022-02-22), so nothing is loaded as an extension. The version on screen is real and recent: the [SQLite changelog](https://sqlite.org/changes.html) lists 3.53.4 on 2026-07-24, and the entry's `sqlite-build.sh` fetches `sqlite-amalgamation-3530400.zip` from sqlite.org with a pinned SHA-256. Two newer releases exist, 3.54.0 (2026-10-09) and 3.54.1 (2026-10-16). Frame 19 lists `matmul`, `dot_product`, `do concurrent`, and coarrays as Fortran built-ins and leaves JSON as a dashed box; the entry contains no JSON parser of its own, which is consistent with that.

The batching description matches the code and, more to the point, the rules. The transcript at 45.70 seconds says "every write that came in during a single pass of the event loop shared one database commit." `bridge.c` runs `if (MHD_run_wait(daemon, 100) != MHD_YES) break;` and then `int ok = app_flush();`, the two lines in frames 24 and 25. The submission README describes the mechanism: "Requests whose responses depend on an open transaction are suspended. On return from the event-loop iteration, Fortran commits; the bridge queues those responses and resumes their connections," and "Ready requests can share a transaction without an intentional batching timer." Rule 6 of the challenge states: "Batching several requests' writes into one transaction (group commit) is allowed if each response waits for its commit," next to the requirement of WAL with `synchronous=NORMAL` or stronger. The six "201 Created" rows in frame 26 are the resumed connections after `COMMIT`.

The README adds limits the graphics skip: the entry retires keep-alive connections once 60,000 are open, shrinks libmicrohttpd's per-connection pool from 32 KiB to 16 KiB, and caps accepted connections at 65,000. The submitter's own throughput tables come from an ARM64 container and carry the sentence "None of these numbers is the official five-minute k6 score."

## Fortran did not win, and a community rerun under the same rules put it 21st

The TikTok's closing leaderboard greys out three rows above Fortran. The creator's YouTube description gives the top figure as 64,000 users, so at least one entry held 1.68x what Fortran held, and the chapter order places Fortran sixth of twelve languages. The TikTok's caption hedges: "Not really, but it did well here!" The narration's "beating Python, Go, and C Sharp implementations that I received" is a true statement about the bottom of that table and says nothing about the top.

A second data point comes from the repository. In [issue #7](https://github.com/arjaythedev/twelve-dollar-server-challenge/issues/7), opened 2026-10-04 with the request "Can you add results with ram usage please?", participant XXMOHAMED012 posted on 2026-10-08 a run of 27 entries under the README's scoring protocol (2-minute warm-up at 1,000 users, 5-minute hold, p95 under 500 ms, p99 under 1 s, under 1% errors) on one Intel i5-13600KF E-core with 2 GiB RAM over loopback. In that table the Fortran entry (#16) held 54,500 users at 5,768 req/s with 0.00% errors and placed 21st of 27, "limited by memory" with 1,987 MiB peak and OOM-killed above that level. The two Python FastAPI entries held 57,500 (#1) and 62,000 (#10), the two C# ASP.NET Core entries 65,250 each, and the Go net/http entry (#18) 40,000. Most entries stopped between 64,000 and 70,000 at the `LimitNOFILE=65535` descriptor ceiling. The author says plainly that "An E-core over loopback is not the droplet," and that is why the two tables disagree. The ranking depends on which resource runs out first. On the droplet Fortran beat Python; on that machine it did not.

Two names the video never says: the challenge owner is GitHub user `arjaythedev`, and the Fortran submitter is `tbsvttr`, whose profile reads Tobias Vetter, Germany. The issue #7 table credits the same user with the C fio-stl (#5), Bun.serve (#4), C++ uWebSockets (#6 and #15), Python Granian (#13), Ruby Iodine (#14), Rust Axum (#17), Go net/http (#18), Zig (#25), and Erlang (#11) entries. Whether the Go entry at 22,000 in the TikTok's table is his, I could not confirm.

## The 1957 date and PR #16 hold up, with one five-minute wrinkle

"Fortran came out in 1957" matches [IBM's history page](https://www.ibm.com/history/fortran): "In 1957, the IBM Mathematical Formula Translating System, or Fortran, debuted. Soon after, IBM made the first Fortran compiler available to users of the IBM 704." Frame 5 flashes a greyed "1956" before "1957 FORTRAN I" settles; I did not source the 1956. 2026 minus 1957 is 69, the number on frame 6, so "almost 70 years" is accurate. The other legible dates on the timeline check out against their originators: Dennis Ritchie's [history of C](https://www.nokia.com/bell-labs/about/dennis-m-ritchie/chist.html) says "C came into being in the years 1969-1973" and "the most creative period occurred during 1972"; the [Python FAQ](https://docs.python.org/3/faq/general.html) says Guido van Rossum first posted Python to USENET "in February 1991"; [Google's open-source blog](https://opensource.googleblog.com/2009/11/hey-ho-lets-go.html) announced Go on November 10, 2009; and the [Rust blog](https://blog.rust-lang.org/2015/05/15/Rust-1.0/) announced 1.0 on May 15, 2015. The Java row is hidden behind the caption in frame 6, so I did not check it. The claim that Fortran is "mostly used for scientific computing" and "never" for web APIs is a characterization I did not try to source; the entry itself is a counterexample to "never."

The "PR #16 open" badge in frames 3, 10, and 27 was true when the graphics were made and false by the time the clip posted. GitHub's API shows [pull request #16](https://github.com/arjaythedev/twelve-dollar-server-challenge/pull/16), titled "Add Fortran libmicrohttpd SQLite submission," opened 2026-10-06 10:16:06 UTC and merged 2026-10-16 21:33:06 UTC. TikTok stamps the upload at 2026-10-16 21:38:46 UTC, five minutes and forty seconds later. As of 2026-10-19 the repository has 344 stars, 197 forks, an MIT license, 124 pull requests by GitHub's search count, and two folders under `submissions/`: `fortran-microhttpd-tbsvttr` and `python-fastapi-cknutson12`. The $12 matches [DigitalOcean's droplet pricing](https://www.digitalocean.com/pricing/droplets), where the $12/month Basic plan is 1 vCPU, 2 GiB memory, 50 GiB SSD, and 2,000 GiB transfer, and rule 8 of the README names "a DigitalOcean Basic droplet: 1 vCPU, 2 GB RAM, no swap" on "Ubuntu 24.04 x86_64." The pass rule in frames 1 and 2 is quoted from the README's scoring section: p95 under 500 ms, p99 under 1 s, under 1% errors, one 5-minute hold.

## Key Takeaways

- **Correction:** The narration's "twice as many users" is 1.73x by the video's own leaderboard (38,000 against 22,000), and the on-screen card already says 1.7x.
- **Verified:** libmicrohttpd is a GNU C library. The entry pins 1.0.2 (released 2025-07-14, SHA-256 matched against the tarball) while the current release is 1.0.10 (2026-08-07), and `MHD_run_wait`, `MHD_suspend_connection`, `MHD_resume_connection`, and `MHD_USE_EPOLL` are all in the 1.0.2 header and all used in `bridge.c`.
- **Verified:** 750 lines is exact, with 575 Fortran lines across three files and 175 C lines in `bridge.c`, and the submitter's README says it is "not an implementation written exclusively in Fortran."
- **Clarification:** The C server layer is within rule 1 of the challenge, which allows any language, framework, and runtime, so "kind of cheating" is the presenter's opinion rather than a rules finding.
- **Partial correction:** A login check is one SQL query for the claims plus an HMAC-SHA256 computed in C through fio-stl; the signature never passes through SQLite.
- **Verified:** SQLite 3.53.4 (2026-07-24) parses JSON via `json_extract` and `json_type`, built in since 3.38.0, and rule 6 explicitly allows one commit per event-loop pass as long as each response waits for it.
- **Context:** Fortran was not the top entry. The creator's results video says the box reached 64,000 users, and a community rerun under the README protocol on different hardware placed the Fortran entry 21st of 27, memory-limited at 54,500 and below both Python FastAPI entries.
- **Unverified:** The 38,000, 32,000, 22,000, and 22,000 per-language figures come only from the creator's graphics; YouTube blocked caption retrieval and the repository holds no results file.
- **Minor:** PR #16 reads "open" in the clip but was merged five minutes before the TikTok's upload timestamp.

## Resources

- [arjaythedev/twelve-dollar-server-challenge](https://github.com/arjaythedev/twelve-dollar-server-challenge) establishes the rules (any language, SQLite only, group commit allowed under rule 6, Nginx optional, pinned builds), the droplet spec, the scoring protocol and pass thresholds, the 2026-10-03 creation date, the MIT license, and the 344 stars and 197 forks as of 2026-10-19.
- [Pull request #16](https://github.com/arjaythedev/twelve-dollar-server-challenge/pull/16) establishes the title, the author `tbsvttr`, the 2026-10-06 open date, the 2026-10-16 21:33:06 UTC merge, and the submitter's description of which layers are Fortran and which are C.
- [submissions/fortran-microhttpd-tbsvttr](https://github.com/arjaythedev/twelve-dollar-server-challenge/tree/main/submissions/fortran-microhttpd-tbsvttr) establishes the 575 plus 175 line split, the pinned libmicrohttpd 1.0.2, fio-stl, and SQLite 3.53.4 with their hashes, the `json_extract` and `auth_query` lines, the `fio_sha256_hmac` call, the suspend-commit-resume design, and the submitter's own disclaimer about his local measurements.
- [Issue #7](https://github.com/arjaythedev/twelve-dollar-server-challenge/issues/7) establishes the community rerun of 27 entries under the README protocol, with Fortran at 54,500 users, rank 21, memory-limited.
- [I Asked Expert Programmers to Max Out a $12 Server](https://www.youtube.com/watch?v=QGWKCaglSBI) establishes, via its yt-dlp metadata, the 2026-10-13 upload, the "64,000 concurrent users" top figure, the "14,050" prior best, and the twelve-language chapter order with Fortran sixth.
- [Which Programming Language Can Handle the Most Users on a $12 Server?](https://www.youtube.com/watch?v=sQXFhh_PiG4) establishes the first video, uploaded 2026-10-02, that benchmarked eight languages on Postgres behind Nginx.
- [GNU libmicrohttpd release directory](https://ftp.gnu.org/gnu/libmicrohttpd/) establishes the 1.0.2 tarball date of 2025-07-14 and the 1.0.10 release of 2026-08-07.
- [libmicrohttpd-1.0.2.tar.gz on mirrors.kernel.org](https://mirrors.kernel.org/gnu/libmicrohttpd/libmicrohttpd-1.0.2.tar.gz) establishes, by download and hash, that the library is a GNU C library, LGPLv2.1+ and eCos licensed, with `MHD_run_wait`, `MHD_suspend_connection`, `MHD_resume_connection`, and `MHD_USE_EPOLL` declared in `microhttpd.h`.
- [SQLite release history](https://sqlite.org/changes.html) establishes 3.53.4 on 2026-07-24 and 3.54.1 on 2026-10-16.
- [SQLite JSON functions](https://sqlite.org/json1.html) establishes `json_extract` and `json_type` and their default inclusion since 3.38.0.
- [facil-io/cstl](https://github.com/facil-io/cstl) establishes fio-stl as the MIT-licensed facil.io C STL with `sha2` and `string` modules.
- [DigitalOcean Droplet pricing](https://www.digitalocean.com/pricing/droplets) establishes the $12/month Basic plan at 1 vCPU, 2 GiB, 50 GiB SSD, 2,000 GiB transfer.
- [IBM: Fortran](https://www.ibm.com/history/fortran) establishes the 1957 debut and the IBM 704.
- [Dennis Ritchie, The Development of the C Language](https://www.nokia.com/bell-labs/about/dennis-m-ritchie/chist.html) establishes 1969 to 1973 with 1972 as the most creative period.
- [Python General FAQ](https://docs.python.org/3/faq/general.html) establishes the February 1991 first public post.
- [Google Open Source Blog: Hey, Ho, Let's Go!](https://opensource.googleblog.com/2009/11/hey-ho-lets-go.html) establishes the November 10, 2009 Go announcement.
- [Announcing Rust 1.0](https://blog.rust-lang.org/2015/05/15/Rust-1.0/) establishes the May 15, 2015 release.
