<- all tokdocs
2026.10.16@arjay_mccandless

The Fortran Entry Held 1.7x the Users of the Best Python Entry by the Video's Own Graphic, and Its HTTP Server Is GNU libmicrohttpd, a C Library

Coding
Watch on TikTok

View on TikTok ->

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, 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, 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 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, 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 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 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, 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: "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 says "C came into being in the years 1969-1973" and "the most creative period occurred during 1972"; the Python FAQ says Guido van Rossum first posted Python to USENET "in February 1991"; Google's open-source blog announced Go on November 10, 2009; and the Rust blog 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, 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, 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

Published October 16, 2026. Writeup generated from a favorited TikTok.