Halo Is the New Doom: AI Is Making All Software "De Facto Open Source"

Title

Halo Is the New Doom: AI Is Making All Software "De Facto Open Source"

Meta Description

AI agents are driving the cost of decompilation and clean-room rewrites toward zero: Halo ported to N64/Dreamcast, a PS5 emulator going from 1 FPS to 120 FPS in a month, REA letting agents reverse-engineer anything, and open-source recreations of Adobe and Office. The era of software being "de facto open-sourced" is accelerating.

Article Content

Seven months ago, developer Remo Jansen published an article titled "Source Code Has Become a Public Good, and SaaS Is Essentially Dead," predicting that AI would dramatically lower the economic cost of clean-room rewrites and that pure software expression was losing its scarcity. At the time, he gave a timeline of five to ten years.

By his own admission: "I was wrong about the timeline."

This month, the prediction is becoming reality at a visible pace—from console cracking and porting to a brutal performance jump in PS5 emulators, to open-source recreations of Adobe and Office making public debuts. These events seem scattered, but behind them is the same force: AI agents are driving the cost of "understanding a piece of software and rebuilding it" toward zero.

Halo Runs on Every Platform It Was Never Meant to Appear On

In just a few days, Halo: Combat Evolved has appeared on multiple platforms it was never designed to support:

• Halo 64: Built on the halo-ce-universal decompilation project, running on real Nintendo 64 hardware, with a custom renderer, four-player split-screen, all 13 original maps, bot battles, and even a Firefight mode that the original Xbox never had. Claude provided substantial assistance with the coding.
• Halo: Dreamcast Evolved: Runs levels like "Pillar of Autumn" on real Dreamcast hardware. The console's CPU is more than three times slower than the original Xbox's and has only a quarter of the memory. Performance is still rough, but the core systems have been ported and are being iterated on publicly.
• Native PC and more platforms: The same decompilation work has produced native versions for Windows, Linux, and Android, supporting online matches of up to 128 players; campaign co-op player counts are also rising, with 32-player co-op already demonstrable. The browser version even has 128-player rooms and split-screen co-op.

These are not simple asset ports. They are built on decompilation results that are close to byte-for-byte identical. What has really changed is the speed of the "last mile": a new renderer, platform adaptation, extended networking code, and extra modes used to take years; now a single developer plus a modern agent can do it in days to weeks.

Halo is becoming the new Doom—the classic that runs on everything. The only difference is that Doom relied on an open-source engine, while today it relies on AI-accelerated decompilation.

Decompilation and clean-room reimplementation are the key premises for understanding this article. Decompilation means recovering readable source code from a compiled binary program (often using tools like Ghidra plus manual and AI-assisted corrections), with the goal of making the reconstructed result behaviorally close to byte-for-byte identical to the original program. Clean-room reimplementation is a legally more cautious approach: one group only observes the program's input/output behavior and writes a specification, while another group, with no access to the original code at all, independently implements it based solely on the specification. Combined, the two keep lowering the line between "I can observe how it runs" and "I can rebuild it under a different license or on different hardware"—and this is exactly the shared technical foundation behind the Halo ports and the Craft series recreations.

PS5 Emulator: From 1 FPS to Nearly 120 FPS in Just One Month

Another high-profile stress test comes from PS5 emulators.

In early September, Demon's Souls: Remake on KyTyPS5 and its forks could only reach 1–2 FPS even on top-tier hardware. A few days later it climbed to 10–18 FPS, a 30 FPS mark appeared in mid-September, and by mid-October a custom build was running above 60 FPS at native 1440p quality settings on an RTX 5070 + Ryzen 7 9800X3D, approaching 120 FPS with DLSS frame generation enabled. The entire game was already completable by the middle of the month.

The historical rhythm of console emulation has never looked like this. In the past, mature emulation of a console generation often took years of polishing, but this time, the community plus AI tools have turned the curve into an almost vertical slope.

The difficulty structure of console emulators and the frame-rate jumps deserve a separate explanation. Emulating a console generation usually takes years because you have to precisely reproduce the CPU instruction set, the GPU graphics pipeline, and memory and synchronization timing; any subtle deviation causes visual errors or crashes. Traditionally this is done by many developers repeatedly debugging and gradually closing the gap. The curve in the article, where FPS jumps from 1–2 to over 60, does not mean the underlying emulation accuracy is already complete; it more likely means key bottlenecks (such as shader translation, JIT recompilation, specific instruction paths) were quickly located and bypassed. Custom builds combined with DLSS frame generation further inflate the apparent frame rate, so "completable" and "fully accurate emulation" are still two different things—but the speed of bottleneck identification itself has been significantly compressed.

REA: Letting Agents Reverse-Engineer Anything

Erupting alongside the ports and emulators is a tool called REA (Reverse Engineer Anything).

It is an MCP server and CLI that lets coding agents like Claude Code, Codex, and Cursor reverse-analyze applications, native binaries, websites, and runtime behavior without source code. It orchestrates existing tools such as Ghidra, Hopper, IDA, and browser instrumentation, and outputs evidence-backed explanations. It reportedly accumulated hundreds of thousands of stars in about two weeks.

The practical effect is this: you can point an agent at a feature, and it can produce a usable understanding and a path to an independent reimplementation. Combined with the clean-room development model, the wall between "I can observe behavior" and "I can rebuild behavior under a different license or on different hardware" is continuing to shrink.

MCP (Model Context Protocol) is an open protocol proposed by Anthropic for letting AI applications connect to external tools and data sources in a standardized way. Coding agents themselves can only read and write text, but through MCP servers they can call real tools like Ghidra, IDA, and browser debuggers, feeding tool outputs back into the reasoning process. REA exists precisely as an MCP server plus CLI, so different clients such as Claude Code, Codex, and Cursor can all reuse the same reverse-engineering capabilities. The significance of this layer is that reverse engineering no longer depends on a handful of experts manually operating heavy tools; instead, it is orchestrated into reproducible, scalable agent workflows.

Adobe and Office "Craft" Recreations: Imperfect, but the Signal Is Loud Enough

In early October, Brandon Thomas's ArtCraft project went public: Rust-based open-source applications billed as clean-room reimplementations of Adobe's flagship tools—PhotoCraft (Photoshop), FilmCraft (Premiere), LightCraft (Lightroom), plus counterparts for Illustrator, After Effects, InDesign, and Acrobat. Claude was deeply involved in building them.

A few days later, the same idea extended to Microsoft Office: WordCraft, GridCraft (Excel), and DeckCraft (PowerPoint).

None of these are finished products. The team itself positions them as early alpha, with feature parity and "ready for real work" metrics typically between 45–60%; file compatibility, edge cases, and polish are all still incomplete.

But imperfection is precisely what makes them meaningful as a signal. They publicly prove that a small team plus frontier models can, within weeks, produce runnable, file-compatible approximations of the two most heavily protected and highest-margin software suites. The UI patterns, core workflows, and file formats that once required years of specialized expertise are now being rebuilt at a visible pace.

File format compatibility is the most underrated barrier for these kinds of recreations. Photoshop's PSD, Word's DOCX, and Excel's XLSX all contain a large amount of undocumented or semi-documented proprietary semantics: layer blending modes, style inheritance, formula recalculation rules, embedded objects, and so on. Being able to open a file is not the same as being able to render it correctly and round-trip save it. So the 45–60% feature parity the team cites actually means the core editing paths are usable, but edge behavior and compatibility remain incomplete. Even so, reaching this level within weeks shows that the format knowledge that once required years of reverse engineering and trial and error is being rapidly absorbed by models and turned into runnable code.

These Stories Share the Same Underlying Variable

They are not isolated technical stunts but different symptoms of the same shift:

• The toolchain for decompilation and reverse engineering has matured;
• Frontier models' capabilities on low-level and system-level code are enough to dramatically accelerate the remaining manual work;
• Agent workflows (and tools like REA) make the process more systematic and no longer dependent on scarce expert knowledge;
• The economic cost of "making a usable version of X on platform Y" or "understanding Z's implementation in order to rebuild it" has collapsed.

The Game Industry May Be the Most Vulnerable of All

Seven months ago, the original author was mainly discussing SaaS. Now, looking at progress in gaming, he believes the game industry is even more exposed.

AAA studios are already struggling with high costs, risk-averse sequels, live-service fatigue, and audience fragmentation. The ability to rapidly reimplement, port, extend, and redistribute games is removing one of the last moats: how hard it is to make a usable version exist elsewhere. When a decompiled classic can run within weeks on N64, Dreamcast, phones, browsers, and PCs with 128-player lobbies, the value of exclusive platform deals, long development cycles, and even some DRM begins to look fragile.

Games that embrace mods and community content are not automatically safe either. Modding communities have historically extended game lifespans, but the new tools accelerate both mod creation and independent reconstruction of the underlying experience itself. As the technical barrier to full replacements keeps falling, the line between "official version" and "community version" becomes harder and harder to maintain.

The original prediction still holds, only broader in scope:

1. Most software will be de facto open source—either forced (protection becomes impractical) or voluntary (fighting it costs more than adapting).
2. Remaining value will concentrate in convenience, operations, trust, data network effects, live services, and experiences that cannot be easily rebuilt offline.
3. Pure code expression—whether a SaaS dashboard or a single-player campaign—is losing its scarcity.

For games, this may be especially brutal. The industry already relies on high fixed costs and hit-driven economics. If the cost of independent reconstruction and redistribution keeps collapsing, the pressure on traditional publishing and exclusivity models will only intensify. Some studios will pivot to live services, social layers, competitive fairness, and continuous content that is hard to mirror; others will not.

Seven months ago, the author wrote that "source code is becoming a public good, and SaaS is essentially dead." This month, Halo became the new Doom, emulators jumped from 1 FPS to 100 FPS, reverse-engineering agents went mainstream, and clean-room approximations of Adobe and Office appeared publicly.

The direction is clearer than it was in March: most software will soon be de facto open source. The only remaining question is how many markets will realize it in time and complete the adaptation.

One-line Summary

AI agents are drastically cutting the cost of software reverse engineering and reconstruction, and most software is becoming de facto open source.

Paragraph Summary

The article revisits Remo Jansen's prediction from seven months ago that "source code has become a public good and SaaS is essentially dead," noting that it is coming true on a timeline faster than expected. In just one month, Halo: Combat Evolved was ported to N64, Dreamcast, browsers, and PC (with 128-player online support); the PS5 emulator for Demon's Souls: Remake jumped from 1–2 FPS to over 60 FPS, approaching 120 FPS; REA lets coding agents reverse-engineer applications without source code; and Rust-based clean-room recreations of Adobe and Office debuted publicly at 45–60% feature parity. The author argues that these events share the same underlying variable: the economic cost of understanding and rebuilding software has collapsed, the game industry is especially exposed, and remaining value will concentrate in convenience, operations, trust, data network effects, and live services.