Every App Is Now Open Source!

The week every binary became a suggestion

A developer called Brandon Thomas, reportedly got fed up with Adobe's subscription terms (and cancellation fees) and answered by shipping Artcraft: open-source, Rust-based stand-ins for seven Creative Cloud apps, Photoshop, Illustrator and Premiere among them. They're free, and they run on Linux, which Adobe has never officially supported.

Around the same time, a separate project called Reverse Engineer Anything (REA) went viral by pointing AI agents at compiled software and getting readable logic back out. Put the two stories together and you get a tempting headline: every app in the world is now open source, whether its owners like it or not.

We think that headline is half right, and the wrong half will be gone soon.

What the tooling actually does

Commercial software ships as compiled machine code, not source. Turning that back into something a human can follow has always been possible. It was just slow, expert work. REA wraps that work in an agent loop. As described, it can handle a wide range of targets:

• Stripped native executables in ELF, PE and Mach-O formats

• JVM bytecode, including obfuscated constant pools

• .NET assemblies built to the ECMA-335 spec

• Bare-metal firmware for specific instruction sets

• OCI container layers and the infrastructure manifests around them

The heavy lifting on Windows binaries comes from Ghidra, the NSA's open-source reverse engineering suite, which does read-only analysis of executables and DLLs. You run REA from Node.js with npx, aim it at an installed app, and ask it how a specific feature works. Some time later you get back C-like pseudo-code, assembly, strings, symbols and call references. On its own that output is close to unreadable. Hand it to a coding agent, though, and you can ask for a reimplementation of that one feature in Rust.

The catch: a clone is not (yet) a product

Early hands-on reports on Artcraft's Premiere replacement aren't kind. The interface looks almost exactly like Premiere's, which is great for muscle memory. Underneath, though, testers describe laggy playback, audio meters that trail behind the picture, and transitions that look visibly rougher than the originals. Writing it in Rust didn't make it fast, because speed comes from engineering decisions and Rust only gives you better odds.

It's also worth remembering that "free alternative to Premiere" has been a solved problem for a while. DaVinci Resolve has a capable free tier (it isn't open source), and Kdenlive is fully open source. What keeps people paying Adobe is decades of polish, codec support, performance tuning and workflow integration. None of that shows up in a decompiled function.

AI made copying the shape of software cheap. It did nothing to make copying the quality of software cheap.

Where it gets genuinely interesting: smaller, sharper tools

Cloning the whole suite is the least useful thing you can do with this. The better idea is to go after one feature. Most heavy users touch maybe a tenth of what a professional app offers. If an agent can explain how a specific timeline behaviour works, a team can rebuild just that behaviour inside a lean, purpose-built tool with no feature bloat.

The same thinking applies to developer services. Watching how a hosted backend's API and UI respond is often enough to understand what you actually rely on, and sometimes that turns out to be small enough to own outright.

The parts nobody should skip

• Legality varies. Many licence agreements forbid reverse engineering, and the exceptions (interoperability, security research) depend on your jurisdiction. "The tool exists" doesn't mean "the use is allowed."

• Clean-room discipline matters. Reimplementing behaviour isn't the same as transplanting someone's code. Clean-room design exists for good reason.

• Your own binaries are readable too. Anything you ship to a client device, including keys, endpoints and business logic, should be treated as public.

How we think about this at Birdhouse

We build with AI agents every day, so none of this surprises us. It does confirm a few things we keep coming back to. Getting the code is the cheap part now. What makes software worth using is everything around the code: knowing which features matter, holding a performance bar, and reviewing output adversarially so you aren't shipping something that only looks like the real thing.

That's why our agents do the building and our people own direction and quality. Agents explore, analyse and draft. A separate review pass tries to break what they made. Humans decide what ships. We also run analysis work in least-privilege sandboxes, because pointing an agent at unknown binaries is exactly where tight boundaries pay off.

So is this the end of software as we know it? No. But it may be the end of software that survives mainly because rebuilding it used to be too expensive. If your moat is "nobody can be bothered to copy us," it's time to find a better one.