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.
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.
OnePdf implements ISO 32000 for reading, three-step repair of damaged files, the security handler’s revisions 2 through 6, signing, and writing PDF/A, PDF/UA-1 and PDF/UA-2. An outside validator decides whether the output is right: of veraPDF’s own 2,906-file corpus, 2,694 converted to PDF/A-2b and every one of those passed veraPDF. A sweep over GovDocs1, a 5,000-file SafeDocs sample and the veraPDF corpus opened each file and interpreted every page with 0 crashes and 0 hangs. It’s about 120,000 lines of C#.
OnePdf is a from-scratch implementation of ISO 32000 and its PDF/A and PDF/UA profiles. The value is having reading, repair, editing, signing and compliant writing exact in one managed library.
OneDocument covers OOXML, the old binary DOC, XLS and PPT, RTF and ODF, and the Word 6/95 and early Excel layouts come from observed files because there’s no spec for them. A save has to keep every part of the package exactly, including parts the library never touches: over a public corpus of 4,900 files, 111,239 of 111,239 parts came back byte-identical. Real Office judges what it writes, and 718 generated files open in Word, Excel and PowerPoint with no repair prompt. It’s about 285,000 lines of handwritten C#, and it renders through OneRender and the libraries under it.
The formats are existing standards. What it adds is a document model that’s a view over the file’s own markup, so untouched parts go back out as the original zip entries and edits keep unknown elements and extensions in order. The same library renders documents, workbooks and decks to tagged, accessible PDF.
OneHtml implements the WHATWG parser with every insertion mode, Selectors Level 4, the CSS cascade, and the ARIA, AccName and HTML-AAM specs that define the accessibility tree. It’s checked against Chrome itself: across 2,095 pages it matched 1,779,203 of Chrome’s 1,840,086 accessibility nodes. A no-edit round trip is byte-identical on all 18,330 corpus pages and stylesheets. It’s about 85,000 lines of C# on the .NET base library alone.
Edits go through a byte-level source map, so an edit changes only the bytes it touches and old snapshots of the DOM stay valid. It computes the accessibility tree Chromium exposes and runs accessibility checks with no browser, with Chromium’s choices written down as a profile.
OneRender implements CSS from the specs: computed values, the box tree, layout, fragmentation and paged media, painting, DOM events, transitions and animations. Its geometry is checked against Chrome on the same fonts, and its six templates match 3,051 of 3,052 elements at both 1280×800 and 390×844. It’s built on four other factory libraries, OneHtml, OneFont, OneImage and OnePdf, and it’s about 89,000 lines of C#.
It’s a browser-class layout engine packaged as a library, with no JavaScript, networking or clock of its own; the host passes the time. One engine serves both a 200-page report and a game UI that updates every frame, and incremental relayout gives the same result as a full rebuild. Output goes to pixels, a versioned display list a game engine can draw, or tagged PDF/UA.
OneFont implements TrueType, CFF, every GSUB and GPOS lookup type, and the script shapers for Arabic, Indic, the Universal Shaping Engine and Thai/Lao. Indic alone means syllable cutting, reph movement and pre-base matras in Microsoft’s documented feature order. The Unicode 17 conformance files for line, grapheme, word and sentence breaking and bidi pass in full, read unmodified. It’s about 11,500 lines of C# with no dependencies.
OneFont is a from-scratch implementation of OpenType layout and the Unicode text algorithms. The value is having shaping, bidi and segmentation exact in one dependency-free library.
OneImage has its own codecs for PNG, JPEG, WebP, GIF, TIFF, BMP and ICO, plus ICC v2/v4 color, JPEG 2000 and JBIG2 for PDF images, PSD/PSB layers, metafiles and SVG. On 2,327 JBIG2 streams from government PDFs, 1,925 decode bit-identical to poppler’s pdfimages and the other 402 are its exact inverse, because pdfimages applies the PDF’s decode polarity and OneImage leaves that to the caller. Lossless JPEG 2000 is bit-exact on the T.803 conformance set. It’s about 145,000 lines of C#.
These are existing codecs and formats, written from scratch. The value is having them exact in one managed library, with pixels computed lazily, tile by tile, only when you save.
OneLite reimplements SQLite 3.53.4’s file format, rollback journal, WAL, SQL semantics, result codes and error messages, plus FTS3/4/5, R*Tree and SQLCipher 4 pages. Compatible means it can share a live database with sqlite3: 10,000 interleaved WAL commits stay consistent from both sides. It was written from SQLite’s public docs with sqlite3 as a black box, and differential testing against sqlite3 found 0 unexplained differences in about 12,000 cases. It’s about 115,000 lines of C#.
OneLite is a from-scratch reimplementation of SQLite, and compatibility is the point. The value is a SQLite engine in pure managed code, NativeAOT and the browser included, that reads and writes standard SQLite files.
OneIndex implements known search algorithms: BM25F with block-max WAND, HNSW, rank fusion, UAX #29 segmentation and Snowball stemmers for 34 languages. The stemmers reproduce the published Snowball vocabularies exactly, 11,481,578 of 11,481,578 words. Durability testing ran about 890,000 fault-injection schedules and more than 7,000 process kills with no lost commit. It’s about 70,000 lines of C#.
The algorithms are known ones, implemented from scratch. The value is text, vector and hybrid search exact in one in-process library, which can also serve the same index to a browser as static files.
OneArchive has its own codecs for Zstandard, LZ4, Deflate, Brotli, LZMA and xz, bzip2 and PPMd, and its own readers and writers for zip, tar, 7z, ISO 9660, cab and more. Its compressed output is part of the contract: each codec and level writes the same bytes on every OS, CPU, runtime and thread count, in every 1.x release. PPMd output is byte-identical to what 7-Zip writes. It’s about 95,000 lines of C#.
These are existing codecs and containers, written from scratch. The value is having them in one managed library whose 1.x contract is that each codec and level writes the same bytes on every platform, so the output can serve as a content address.
OneMail implements MIME and Outlook’s formats from Microsoft’s Open Specifications, MSG and PST among them, plus mbox, Maildir, calendars, contacts and SMTP, IMAP and POP3. Untouched MIME writes back byte-identical, 523,424 of 523,424 messages including the Enron maildir. PSTs it writes, including edits made in place to an existing store, open in Outlook. It’s about 112,000 lines of C#.
The formats and protocols are existing ones. What’s uncommon is writing Unicode PST from managed code, as a new file or in place in an existing store, with in-place writes committed by MS-PST’s two-root protocol and the results opened in Outlook. Its forensic recovery got back more items than Outlook’s own repair tool in all 12 damaged stores compared.
OneCrypto implements ASN.1, X.509 and path validation, CMS, PKCS#8 and #12, OpenSSH keys, OpenPGP RFC 9580 with post-quantum algorithms, and the modern curves, all on the .NET base library. OpenPGP messages written by GnuPG, Sequoia, RNP, OpenPGP.js and gosop parse and write back byte for byte, and two-way interop runs against each of them with 0 failures. Path validation passes all 9,572 BetterTLS cases. It’s about 82,000 lines of C#.
OneCrypto is a clean-room implementation of published crypto standards. The value is having them in one managed library that also runs in the browser, with every secret-handling primitive under a timing test.
oneyaml implements one spec, YAML 1.2.2, three times: natively in Rust, Go and C#, at about 87,000, 34,000 and 46,000 lines. The Rust parser scores 402 of 402 on the yaml-test-suite under a strict criterion that also checks its lossless events and exact diagnostics. Every YAML 1.1 behavior is a named setting, off by default.
YAML is an existing standard, and byte-preserving round trips exist elsewhere. What’s uncommon is that typed reads and in-place edits share one parser and one resolver, so they can’t disagree about what a file means, and one shared conformance kit holds the Go and C# libraries to the same cases through their public APIs.
OneContact reproduces libphonenumber 9.0.43’s behavior and implements RFC 5322 email, WHATWG URL, the Public Suffix List and UTS #46. The phone side has 0 mismatches against libphonenumber in 2,819,630 results, and the URL side passes all 896 of WPT’s URL tests. It’s about 50,000 lines of C#.
Each piece reproduces an existing standard or reference library. The value is phones, email, URLs, addresses, names and page extraction exact in one library that never touches the network.
The text core is Myers, patience and histogram diff, held to outside tools: edit lengths equal GNU diff --minimal on 9,483 of 9,483 cases, and three-way merges equal git merge-file byte for byte in all three conflict styles. The document layer marks changes on the PDF pages and re-reads its own marks to confirm they match the change list. It’s about 39,000 lines of C#.
The diff algorithms are known. What it adds is document redlines where every comparison is checked to be invertible: old plus the changes gives new, and new minus the changes gives old. Changes come back typed with resolved values, like “30 days → 60 days”, and a renumbering counts as one change.
OneModel reads ONNX with its own protobuf reader, any opset from 7, and runs it on its own kernels for AVX2, AVX-512, NEON and portable SIMD, with graph optimization, quantization and training. On the ONNX 1.22.0 backend suite it passes 1,580 cases in fast mode with 0 failures. Exact mode has to give the same output hash on every x64 and arm64 path, NativeAOT and the browser, which rules out fused multiply-add and fixes the order of every addition. It’s about 73,000 lines of C#, and its GPU sessions run on OneGpu.
ONNX runtimes exist; OneModel adds an exact mode that gives the same bits on every CPU path and in the browser, at any thread count. The rules are written down, one accumulator per output in a stated order, no fused multiply-add and its own fixed polynomials for exp and tanh, so a port can reproduce the bits. It also trains, in the same managed library.
OneNlp implements five tokenizer families, UAX #29 segmentation, and a full neural pipeline: tagger, lemmatizer, biaffine dependency parser, entity recognizer and classifiers. Its tokenizers match Hugging Face tokenizers and tiktoken with 0 mismatches across 12 families, down to ids, offsets and special-token masks. It’s about 52,000 lines of C#, built on OneModel for inference and training.
The components are established NLP techniques. The value is running and training the whole stack in managed .NET, with models shipped as NuGet packages.
OneSpeech runs existing models: Whisper, Qwen3-ASR, Moonshine and Parakeet for recognition, plus alignment, voice activity detection, diarization and speaker embeddings. It reads PyTorch checkpoints, safetensors and NumPy files itself, and Whisper large-v3-turbo’s word error rate on LibriSpeech is within noise of openai-whisper’s. It’s about 17,000 lines of C#, with the heavy lifting in OneModel and OneAudio.
OneSpeech implements existing published models and decoding methods. The value is running them in managed .NET on OneModel, with no native inference runtime.
OneOcr has its own models, a page detector, line recognizers for Latin, Greek and Cyrillic, and a document extractor, defined by 20 written specs, and it trains them with its own backward passes. Output is bit-identical across AVX-512, AVX2, SSE/NEON and scalar paths at any thread count, which takes a fixed 16-lane accumulation order and its own polynomial exp and tanh. It’s about 43,000 lines of C# on its own SIMD kernels, not OneModel.
When you add an LLM pass, OneOcr sends the page along with its own word list, and the model has to cite the word ids each value came from. Every value is then checked against those words, the rest of the page, or arithmetic over cited amounts, and a value that doesn’t match is marked as a possible hallucination and asked for once more. The check is deterministic, and its spec says a port must reproduce it exactly.
OneLlm puts Anthropic, OpenAI and Gemini, first-party and through Bedrock, Vertex and Azure OpenAI, plus any OpenAI-compatible server, behind one message model with streaming, tools, structured output and reasoning replay. Each provider is checked by replaying recorded fixtures that compare request bytes and parsed results. It also has its own prompt template language, diff-tested against Go’s text/template on 12,858,638 generated templates. It’s about 62,000 lines of C#.
The provider layer implements existing vendor APIs. The value is one message model over all of them, with agents, scripts and deciders as files you can persist, fork and resume.
OneModelContext implements every Model Context Protocol revision from 2024-11-05 to 2026-07-28, as client and server, over stdio and Streamable HTTP, with OAuth 2.1 and an embedded authorization server. Run as a black box, it passes the official conformance suite’s server scenarios at every revision. Its JSON-RPC, SSE, HTTP, OAuth and JOSE layers are its own code on the base library, about 43,000 lines of C# in all.
It’s a clean-room implementation of a published protocol. The value is both protocol eras behind one API, so application code is written once against the modern semantics.
OneEcma implements ES2026 in strict and sloppy mode, with its own RegExp engine, ECMA-426 source maps and Intl for six locales. On test262 it passes 22,973 language tests and 18,337 built-ins tests. Error messages and stack traces use V8’s exact wording, and lodash, preact and react SSR output must equal Node’s byte for byte. It’s about 78,000 lines of C#.
The engine is a from-scratch implementation of ECMA-262, 402 and 426. The value is a sandboxed JavaScript runtime in pure .NET whose error reports, built by replaying the failed run with tracing on, say where the failing value came from and how to fix it.
OneShader compiles Shader Model 6 HLSL to three targets, SPIR-V, Metal Shading Language and WGSL, including wave intrinsics, 16- and 64-bit types, bindless resources and cooperative matrices. Every target is checked by outside tools: spirv-val and a GPU run beside DXC’s compile for SPIR-V, naga and browser WebGPU for WGSL, and Apple’s compiler and Metal for MSL. Buffer offsets and strides must equal DXC’s. It’s about 58,000 lines of C#.
It’s an HLSL compiler in C# that runs inside dotnet build: shader mistakes become MSBuild errors on the HLSL line, and the generated C# structs match the compiled layout, so a CPU/GPU layout mismatch fails the build. It also compiles cooperative matrices with bfloat16_t, which the repo states DXC cannot compile.
OneGpu drives Vulkan 1.3, Metal through the Objective-C runtime and browser WebGPU from C#, with no native binaries of its own. Its ML kernels include FlashAttention-style attention that never writes the score matrix to memory and a GEMM that picks cooperative-matrix variants from the device’s capabilities. It’s about 24,000 lines of C# plus HLSL kernels compiled by OneShader.
The kernel algorithms are published ones. What’s uncommon is ONNX-class ML kernels on Vulkan, Metal and browser WebGPU from pure C#, with no CUDA. 41 of its 62 kernel files are written once in HLSL and compile to all three APIs; the rest are vendor fast paths with portable fallbacks.
OneAudio implements Opus, Vorbis, FLAC, MP3, AAC including HE-AAC, and AMR and AMR-WB from the specs, plus BS.1770 loudness. Several have to be bit-exact against the reference: the Opus encoder’s packets match the RFC 6716 reference encoder byte for byte in 269 of 269 configurations, and AMR decoding is bit-exact on all 573 3GPP test sequences. It’s about 57,000 lines of C#.
These are published codecs and loudness standards, written from scratch. The value is having them exact in one managed library, with a mixer that allocates nothing while it renders.
OneMedia reads MP4, Matroska, MPEG-TS, ASF, AVI and a long list of other containers, writes MP4, Matroska, MPEG-TS and WAV, and reads subtitles from SRT to CEA-608 and PGS bitmaps, all without decoding a sample. Tags and facts agree with ExifTool and MediaInfo on 116 files, and 445 untouched tag-edit round trips come back byte-identical. It’s about 134,000 lines of C#.
The container formats are existing standards, implemented from scratch. The value is reading, editing and repairing nearly every common container in one managed library with no dependency beyond the base library.
OneGame is a whole engine: 2D and 3D renderers, client/server sync, its own Noise-protocol encryption, Wayland, X11 and Win32 platform layers, glTF import, and Roslyn generators and analyzers. It’s built on 13 packages from eight other factory libraries plus oneyaml, including physics, GPU, shaders, rendering and audio. Sample games must give the same state hashes on Linux and Windows in CI. It’s about 122,000 lines of handwritten C#.
A game is plain C# and text assets, and every operation is a command that returns JSON: build, run headless, test YAML scenarios, capture frames, record and replay, poke live state over MCP, and hot-reload code into the running game. Determinism rules are compile errors, and the analyzer follows every call out of simulation code to any depth. It’s built so an AI agent can make a game from a terminal.
Correctly rounded means returning the IEEE 754 nearest value of the exact mathematical result, for 21 functions in float and double. OneMath does it with Ziv’s method: a fast table stage settles most inputs, and when the rounding is in doubt a double-double stage and then an exact 500-bit stage run. All 232 float inputs were checked for the 17 unary functions, with 0 not correctly rounded. It’s about 8,500 lines of C#.
Correctly rounded results are the same bits on every machine, which ordinary Math.Sin doesn’t promise: Microsoft’s docs say its result may differ between operating systems or architectures. OneMath never calls Math.Sin or fused multiply-add, an analyzer enforces that, and no 1.x release changes any bit. OnePhysics and OnePath build their determinism on it.
OnePath implements A*, JPS, JPS+, Theta*, HPA*, D* Lite, flow fields, a Recast-class navmesh pipeline and ORCA crowds. Grid path costs equal the Moving AI benchmark’s published optimal lengths, and 3D navmesh coverage is within 0.35% of Recast 1.6.0 on the same settings. Results are bit-identical on x64, arm64 and WebAssembly. It’s about 49,000 lines of C#, built on OneMath.
Results and saved state are bit-identical on x64, arm64 and WebAssembly, so searches, flow fields, navmeshes and crowds restore to the same bytes on every machine in a lockstep or rollback game. The algorithms underneath are known ones, which the repo names, implemented from scratch for grids, graphs, navmeshes and crowds in one package.
OnePhysics covers rigid bodies, joints, ropes, cloth, soft bodies, fracture, particle fluids, shallow water, granular matter, characters, vehicles and ragdolls, in 2D and 3D. All of it has to stay bit-identical, so it uses only exact + - * / and sqrt plus OneMath’s functions, fixed-order reductions and a graph-colored solver. CI hashes every step: 165 of 165 scenarios match on Linux x64 and arm64, macOS arm64 and Windows x64, on eight threads, under NativeAOT and in the browser. It’s about 137,000 lines of C#.
The physics methods are published. What’s uncommon is the guarantee: the same world state, bit for bit, on every OS, CPU, vector width, WebAssembly mode and thread count. That’s what lockstep and rollback multiplayer need, and the tools for it are built in: byte-exact snapshots, per-step hashes, replay checks and a desync finder that reports the first difference.
OneScope’s scope is bounded: its own probe, session and cache formats, and no outside spec. The work is in seek and attach: a seek restores the nearest keyframe and re-simulates to land on the same hash as straight play, and a live attach re-simulates the stream so the viewer’s hash matches the host’s at every step. It’s about 15,000 lines of C#, and the window is built on OneGame.
It treats a deterministic run as a pure function of its recording, so you can seek to any step, fork from it, poke state and see the step where the fork diverges. It attaches to a running program without changing or slowing it, and every window action is also a CLI command and an MCP tool, so an agent can debug with it the same way.
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.
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.
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 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 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.
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 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.
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.
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.
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.
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.