Open Cadet: how we rebuilt Space Cadet Pinball as fully open source
By Andrew Nakas · Published July 1, 2026 · Updated July 1, 2026 · ~10 minute read
3D Pinball for Windows – Space Cadet is one of the most beloved pieces of software Microsoft ever bundled. It shipped with Windows for years, then quietly disappeared after XP. There's a wonderful open-source revival of it — but it has always come with an asterisk: you have to bring your own copy of the original data file. We set out to remove that asterisk. The result is Open Cadet: a from-scratch, public-domain data package that lets the open engine run with zero Microsoft files — and, for the first time, makes the whole game freely redistributable. Here's how we did it, and why it opens the door to a lot more than one table.
The problem: a great open engine, chained to a proprietary file
The engine half of Space Cadet is a solved problem. The project k4zmu2a/SpaceCadetPinball is a faithful, MIT-licensed reimplementation of the original game's C++ — the physics, the rendering, the table logic, all rewritten cleanly and released as open source. It even compiles to WebAssembly, which is what lets a pinball table run in a browser tab at all.
But the engine is only half the game. All of the content — the playfield artwork, every sprite, the color palette, the sound effects, the table geometry, the physics constants — lives in a single proprietary binary called PINBALL.DAT, plus a set of .wav sound files. Those files are Microsoft's, and they were never open-sourced. So every web port of the engine (alula's, and the ones that followed) says the same thing: supply your own PINBALL.DAT from a Windows XP install. No data file, no game.
That's a real barrier. It means the "open-source Space Cadet" you can play is only open-source in half — the engine is free, but you still need a proprietary artifact most people no longer have lying around. We wanted a version with no strings attached, one we could legally host and let anyone play instantly. That meant building a new data file from nothing.
The legal foundation: clean-room, and the difference between facts and art
You cannot just copy Microsoft's data file and relabel it — that's the artwork and audio, and it's copyrighted. But copyright protects expression, not facts. That distinction is the entire basis for what we did, and it's the same principle behind projects like Wine and ReactOS: you're allowed to build an original implementation that interoperates with a documented format.
So we split the data file into two buckets:
- Facts — reused for interoperability. The container's structure (how groups and records are laid out), the group names and type codes the engine looks up, the table geometry (wall-segment coordinates, bumper positions, the table boundary), the physics parameters (elasticity, gravity, ball radius, thresholds), and the filename contract the engine expects (e.g.
sound12.wav). These are measurements and specifications, not creative expression. Under the reasoning of Feist v. Rural, facts and data dictated by function aren't copyrightable — and reusing them is exactly what interoperability requires. - Expression — created entirely from scratch. Every pixel of art, the color palette, every sound, and every text string. None of it copied, sampled, or traced. This is the part that would infringe if you reused Microsoft's, so this is the part we rebuilt.
The format itself was already documented, because the engine is open source: k4zmu2a's parser (partman.cpp) spells out the exact byte layout of a PINBALL.DAT — a header signature, then N groups, each holding typed entries (8-bit sprites, a 256-color palette, 16-bit depth maps, integer arrays for geometry, float arrays for physics, and strings). Knowing the format meant we could write a valid file the engine would happily load; the only open question was what to put in it.
Rebuilding the data, piece by piece
The build broke down into three kinds of content.
Original art in a "neon space" style
Rather than try to clone Microsoft's blue-gradient table pixel for pixel (which would be both legally risky and creatively pointless), we made something that's spiritually the same — a top-down space-themed pinball table — but visually its own thing: a darker, neon aesthetic. Every sprite is original: the playfield background, the ball, the flippers and their animation frames, the bumpers in lit and unlit states, the plunger, the rollover lights, the targets, the score-panel digits. All of it procedurally generated original art, drawn independently rather than derived from any existing image.
The format has two art-related constraints worth calling out. First, all 8-bit sprites share one 256-color palette — background, ball, and every object have to agree on the same colors — so the palette had to be designed as a single coherent set. Second, each sprite has a matching 16-bit depth map. The engine uses those z-values as functional geometry: they tell the renderer the viewing angle and how surfaces catch light, so the flat table appears to sit at the correct three-quarter perspective. We treated the depth magnitudes as the facts they are (they drive the projection), while drawing every sprite silhouette from scratch.
47 sound effects, synthesized from waveforms
The audio doesn't live inside the data file — the engine loads sounds as separate .wav files, referenced by number (sound1.wav, sound12.wav, and so on). That filename-to-event mapping is a fact; the actual audio is not. So we generated 47 original sound effects from scratch, synthesizing each waveform with numpy — sine tones, filtered noise, and decay envelopes shaped into plunger releases, bumper hits, flipper clacks, drains, and mission jingles. No sample was recorded or copied from anywhere; every clip is math turned into a .wav.
The container, assembled by a builder script
With original art and audio in hand, a builder packs everything into a PINBALL.DAT the engine can parse: the header struct, the quantized 8-bit sprites plus their shared palette, the depth maps, the geometry and physics arrays, and original text strings for labels and mission names. The output passes the engine's own loader without complaint — which is the whole test. The finished data package ships with about 1.4 MB of table data alongside the engine's WebAssembly binary.
Putting it in the browser
Because the engine already targets WebAssembly, hosting Open Cadet is the easy part. The build is a standard Emscripten bundle — a .wasm binary, a JavaScript loader, and a packed virtual filesystem (.data) that contains our PINBALL.DAT and all 47 sounds. It loads in a plain browser tab, no plugins, and one small nicety: because browsers suspend audio until you interact with the page, the loader listens for your first click or key and resumes the sound automatically. Unlike our Wine- and DOSBox-based apps, this is a native WebAssembly port of the game itself, so it runs at full speed. You can play Open Cadet here right now — nothing to download, nothing proprietary involved.
Licensing: CC0, so anyone can build on it
The whole point was to remove restrictions, so the data package is released into the public domain under CC0. The art, the palette, the sounds, and the strings are all original works dedicated to the public domain — copy them, modify them, ship them commercially, no permission needed. Combined with the MIT-licensed engine, that makes Open Cadet the first version of this game that's free all the way down. (To be clear about what it is and isn't: Open Cadet is not affiliated with or endorsed by Microsoft, and it deliberately shares none of the original's artwork, audio, or exact wording — only the functional format and physics that interoperability requires.)
The future: more boards, one open platform
Here's the part we're most excited about. Once you have an open engine and an open, well-understood data format with a working builder, a single table stops being the ceiling — it becomes a template. The same pipeline that produced the neon table can produce others:
- New tables. Different themes, layouts, and rule sets — each one just a new set of original sprites, sounds, and a geometry/physics description fed through the same builder. Nothing about the engine has to change.
- Community-made boards. Because the format is documented and the builder is straightforward, designing a table becomes an art-and-tuning problem, not a reverse-engineering one. A CC0 baseline means people can fork the neon table, swap the art, retune the physics, and share the result freely.
- A shared, legal foundation. Every board built this way inherits the same "no proprietary files" guarantee, so any of them can be hosted and played instantly in a browser — the same way Open Cadet is today.
Space Cadet was the proof of concept: take a game that was locked behind a proprietary data file, separate the facts from the art, rebuild the art from scratch, and hand the whole thing to the public domain. The engine was already free. Now the content can be too — and there's no reason to stop at one table.