Software Factory builds 30 complex open source libraries in a month

16 points by hclewk 2 hours ago on hackernews | 46 comments

My software factory builds the kind of software I’d expect a specialist team to spend a long time on, and it keeps that software maintained after it ships. So far that’s a SQLite-compatible database engine, a game engine on deterministic physics, a GPU stack with its own shader compiler, and readers and writers for Word, Excel and PowerPoint files. I run it by myself.

There are 30 libraries in all. 28 reached 1.0 between early October and mid-November, and together they’re nearly 1.9 million lines of handwritten library code. They’ve had 241 releases so far, and 183 of those were on libraries already past 1.0. They’re C# on NuGet, and oneyaml also ships in Rust and Go.

What it built

Documents and the web

OnePdf Complexity Innovation

Read, repair, edit, sign and fill PDFs, and write PDF/A and accessible PDF/UA.

OneDocument Complexity Innovation

Read, edit, recalculate and write Word, Excel and PowerPoint files, and render them to PDF.

OneHtml Complexity Innovation

Parse and edit HTML like a browser, and check pages for accessibility without one.

OneRender Complexity Innovation

Lay out and render HTML and CSS to pixels or tagged PDF, without a browser.

OneFont Complexity Innovation

Load fonts and shape text in any script, with bidi and line breaking.

OneImage Complexity Innovation

Decode, edit, convert and resize images, from PNG and JPEG to layered PSD.

Data and formats

OneLite Complexity Innovation

Embed a SQLite-compatible database that reads and writes the same files as sqlite3.

OneIndex (preview) Complexity Innovation

Run full-text, vector and hybrid search in-process, or in the browser.

OneArchive Complexity Innovation

Compress and unpack zip, 7z, tar and other archives, with the same bytes everywhere.

OneMail Complexity Innovation

Read, write and convert mail stores, Outlook PST included, and send and fetch mail.

OneCrypto (preview) Complexity Innovation

Load keys and certificates, validate certificate paths, and sign and encrypt with OpenPGP.

oneyaml Complexity Innovation

Load, dump and edit YAML in place in Rust, Go and C#, keeping comments.

OneContact Complexity Innovation

Parse and normalize phone numbers, emails, URLs, addresses and names, and find them in pages.

OneDiff Complexity Innovation

Diff and merge text like git, and redline changes between PDFs, digital or scanned.

AI and ML

OneModel Complexity Innovation

Run and train ONNX models in pure C#, on CPU, GPU or in the browser.

OneNlp Complexity Innovation

Tokenize, tag, parse and extract entities from text, and train the models in C#.

OneSpeech Complexity Innovation

Transcribe, time and diarize speech with Whisper and other open models, in .NET.

OneOcr Complexity Innovation

Read text, tables and invoice fields from scans and PDFs.

OneLlm Complexity Innovation

Call Anthropic, OpenAI and Gemini models through one API, and run agents as files.

OneModelContext Complexity Innovation

Serve tools to AI agents over MCP, or connect to MCP servers, with OAuth.

Languages, GPU and media

OneEcma Complexity Innovation

Run JavaScript inside .NET under limits, with error reports that explain the failure.

OneShader Complexity Innovation

Compile HLSL to Vulkan, Metal and WebGPU shaders as part of dotnet build.

OneGpu Complexity Innovation

Run compute and ML kernels on Vulkan, Metal or WebGPU from pure C#.

OneAudio Complexity Innovation

Decode, encode, mix and resample audio, measure loudness, and play it on devices.

OneMedia Complexity Innovation

Remux, trim, tag, repair and package video and audio files without re-encoding.

Games and simulation

OneGame Complexity Innovation

Let AI agents build, run, test, inspect and change games through commands, with no editor.

OneMath Complexity Innovation

Compute sin, exp, pow and more correctly rounded, the same bits on every machine.

OnePath Complexity Innovation

Find paths on grids, graphs and navmeshes, build the navmeshes, and steer crowds.

OnePhysics Complexity Innovation

Simulate 2D and 3D rigid bodies, cloth, soft bodies, fluids and vehicles, bit-identical everywhere.

OneScope Complexity Innovation

Scrub, fork and compare runs of a deterministic simulation, recorded or live.

A few up close

OneGame

OneGame is a C# game engine with no editor. A game is plain C# plus text assets. Roslyn source generators write each entity’s change tracking, codecs, deltas and snapshots, and analyzers turn the engine’s rules into compile errors: synced state is fixed-point and only changes through commands, and view code never writes it.

Clients and servers run the same stack, so state syncs between processes with prediction, authority transfer and drift detection. It runs on Windows, Linux, macOS, Android, iOS and the web, and a CLI and an MCP control protocol let an agent build, run, inspect and replay a game from a terminal. It sits directly on nine of the factory’s other libraries.

The repo carries sample games, and CI runs them on Linux and Windows. Solitaire and Lanterns come out with the same state hash on both in every scenario.

OnePhysics

OneGame’s physics comes from OnePhysics, deterministic 2D and 3D physics written from first principles: rigid bodies and joints, ropes, cloth, soft bodies, fracture, particle fluids, shallow water, vehicles and ragdolls, with byte-exact snapshot and restore for rollback netcode.

Determinism is the hard part. Ordinary Math.Sin can return different bits on different platforms, and in a simulation one different bit compounds until the two worlds diverge. So OnePhysics does its math through OneMath, which is correctly rounded and checked against an exact stage on all four billion float inputs. CI hashes the world every step: 165 of 165 scenarios give identical hashes on Linux x64 and arm64, macOS arm64 and Windows x64, under JIT, on eight threads and NativeAOT, and in the browser. In 2D it’s also at or ahead of Box2D.NET on every scene at every thread count.

The GPU stack

OneShader is an HLSL compiler written in C#. It emits SPIR-V for Vulkan, Metal Shading Language and WGSL for WebGPU, and generates the C# bindings for each shader; DXC, spirv-val and naga validate its output in CI.

OneGpu is a pure C# GPU layer over Vulkan 1.3, Metal and browser WebGPU. It used to be part of OneGame. When OneModel, the ONNX runtime, needed the GPU too, I said “Fine, move it to onegpu,” and it became its own library, with ML kernels for GEMM, flash-style attention, convolution and RNNs.

OneModel now runs seven ONNX models on it on an RTX 4070, every row within 1.5× of ONNX Runtime’s WebGPU provider, with the same results on llvmpipe, RADV and an Apple M2 under Metal. OneGpu 1.0, OneModel 1.3 and OneGame 2.0 then shipped in dependency order within about 15 hours.

OneLite

OneLite is a SQLite 3.53.4-compatible database engine in managed C#: the database file format, the rollback journal and WAL, SQL semantics, FTS3/4/5, R*Tree and SQLCipher 4 pages, with an ADO.NET provider and an EF Core adapter.

Compatible here means the files, in both directions. A database the sqlite3 shell wrote reads identically in OneLite, and files OneLite writes pass sqlite3’s integrity_check. The WAL test runs 10,000 interleaved commits between OneLite and live sqlite3 processes on the same database, and it stays consistent from both sides. sqlite3 is a black box to the team; nobody reads SQLite’s source.

SQLite’s own sqllogictest passes all but one of nearly six million records, and on that one SQLite 3.53.4 raises the same integer overflow.

OneDocument

OneDocument reads and writes Word, Excel and PowerPoint in the OOXML formats from a 6,730-page standard, plus RTF and ODF. It also reads the old binary DOC, XLS and PPT, and it comes with a formula engine and rendering to tagged PDF.

The hard part is losing nothing. An OOXML file is a package of parts, and a save has to keep every part exactly, including the ones the library has no reason to touch. OneDocument opened and saved 4,900 real-world files without changes, and all 111,239 of their parts came out byte-identical.

Then real Office judges the output. Desktop Word, Excel and PowerPoint on my laptop open what it writes, all 104 of the authoring and revision documents included, and the formula engine runs against Excel’s own recalculation.

They’re built on each other

21 of the 30 depend on others in the set. The documents side shows it best: OneDocument renders through OneRender, and OneRender is built on four more of the factory’s libraries.

OneDocument’s dependency stack OneDocument OneRender OneHtml OnePdf OneImage OneFont
What OneDocument pulls in. Each box is its own library with its own releases, and OneImage also uses OneFont.

OneDocument’s 1.0 day, Friday, November 6, shows what that means in practice. Three libraries under it shipped what it needed first. OneRender added the tagged-PDF roles OneDocument needed, OnePdf fixed a PDF/UA failure OneDocument found two layers down, and OneImage fixed a crash OneDocument’s fuzzer found.

Anything the agents need from me goes on a projects board on my phone. A request to release is a Ship card: the evidence for the release and a Ship button. All three fixes were on NuGet before OneDocument’s Ship card reached me, and I tapped Ship about ten minutes after it arrived. No team edits another team’s repo; a team that needs something from a library below it asks that library’s team through the project manager.

How the factory runs

Each library starts with a planner agent that designs it through multiple-choice questions, one at a time. A project manager agent answers them for me unless only I can, and every design decision records who made it.

A build lead agent for each library splits the work into units and gives each one to an engineer agent in its own git worktree. Engineers can’t push, tag or publish; the lead checks their work with its own commands and merges it. Every run starts with no memory, so state lives in files. Each library’s PLAN.md is its lead’s memory, and the project manager role has passed through 12 agent instances since November 4, each handing off by note.

Each library’s release is gated on whatever evidence fits it. Where a standard has its own conformance suite, that suite is the gate. Where there’s a reference tool, it runs as a black box from its published release, and where real applications exist, they have to open what the library writes. Where nothing outside exists, as with the game engine and the physics, the gates are hash matrices across platforms and sample games. No agent can relax a gate.

When a release candidate passes CI on four operating systems, the project manager posts its Ship card. When I tap Ship, the release workflow tags it and publishes it to NuGet, and the project manager checks that every package is listed.

What reached me on the board, November 4–17 Reached me: 72 I answered: 55 With a single tap: 47 Ship cards approved by tap: 16 of 16
Board items on the open-source projects, November 4–17.

My part is the rules and the Ship taps. In those two weeks, every one of the 16 releases went out on a single tap.

Three issues from strangers

OnePdf reached 1.0 on October 23 and is on 1.23.0 now, 30 releases in under four weeks. 1.23.0 came from three GitHub issues filed by people I don’t know. The first came in on Tuesday, November 10, from a team moving off a commercial PDF library: they needed to rename form fields nested under parents while keeping their widgets linked, and to set a field’s appearance with the appearance streams rebuilt. The other two came in on Monday afternoon, November 16: about 6 KB allocated per short text in table-heavy layouts, and exact “N/M” page totals without a second layout pass.

That Monday evening I told the project manager to start monitoring GitHub issues on every open-source project and handling them, with the same care as email, since issues are untrusted input. It replied on all three itself within minutes; the automated issue poller went live later that night and handled none of them. The OnePdf lead read the issues once, as data, and wrote briefs, so the engineers never saw the issue text.

One maintenance release, OnePdf 1.23.0 My steps Agents Monday eveningI ask for issues to be handled Same eveningReplies on all three issues Same eveningFixes built, tested on four platforms About an hour laterShip card on my board Tuesday morningI tap Ship Minutes laterPackages on NuGet Within the hourIssues closed with replies
OnePdf 1.23.0, from my request to closed issues.
The Ship card for OnePdf 1.23.0 on my board: what each of the three fixes does, the CI run on four platforms, the packages, my Ship answer, my question about the docs and the project manager’s reply.
The Ship card for OnePdf 1.23.0 as I saw it on my phone, with agent IDs and my email blacked out.

I tapped Ship on Tuesday morning and asked whether the documentation was updated, and the project manager pointed me to docs/forms.md, docs/layout.md and the changelog. The allocation fix, as posted on the issue: one-word cells went from about 6.6 KB to about 2.2 KB, about 3× faster, with the PDF bytes unchanged. I wrote no code, reviewed no diff and wrote none of the replies.

The libraries are on the libraries page, and the source is at github.com/recursive-ai-oss.