Liberate Closed Source

Dear Captive User,

I want to begin with something that is long overdue in our industry: genuine, heartfelt pity toward the proprietary software industry.

Thank you.

Thank you, sincerely, for showing us exactly what not to do.

Now: it is time for us to stop you.

Not because you have done anything technically illegal. You have done everything by the book. You have been so restrictive, so unreasonably, almost suspiciously secretive, that you have made it possible for an entire global economy to run on software that nobody is allowed to fix, maintained by teams that are forced to ship garbage, governed by End User License Agreements that nobody technically reads. It is a miracle of corporate extraction. It is also, from a usability standpoint, completely insane.

At the Bonus Collective, we believe there is a better way. We believe it because we built it, and we would very much like to give it to you for free.

The Legal Crowbar in the Foundation

A very brief bit of background, because it matters enormously for what comes next.

Copyright law has been around, in one form or another, since the Statute of Anne in 1710. But in 1879, the U.S. Supreme Court drew a line in Baker v. Selden that still holds today: copyright protects expression, but not ideas. You can own the specific, obfuscated, eight-layers-deep-bundled way you wrote a terminal application. You cannot own the terminal application itself. Anyone who independently recreates the same functionality — using different code, different expression, and zero exposure to your original source — is legally in the clear. This is not a loophole. This is the entire foundation of American software law, and it has been stable for 147 years.

This gave rise to "cleanroom engineering."

In the 1980s, Phoenix Technologies used this exact technique to clone the IBM BIOS. One engineer studied every behavior of the original. A second engineer, who had never seen IBM's code, built a compatible BIOS from the spec alone. It is perfectly legal.

We recently replicated Phoenix's work using open-weights AI models. The megacorps use closed AI to steal open source; we use open AI to dismantle closed source.

Copyright and EULAs were the electric fences that made vendor lock-in feel enforceable for forty years. They worked because the cost of a genuine, legally clean reimplementation was so absurdly high that only governments and IBM competitors could afford it. That cost has now collapsed to roughly the price of a mid-sized espresso. Our models walk through the fences without noticing they are there.

The Structural Case Against Depending on Megacorps

The appeal of closed source software has always been, and I am quoting the brochures verbatim, that it is "secure," "enterprise-grade," and "maintained by a team of professionals." All three of these claims are marketing copy. All three are, more importantly, the source of the problem rather than any kind of solution.

"Secure" is, in practice, a polite euphemism for security through obscurity — the idea that nobody can exploit the bugs if nobody is allowed to see them. "Enterprise-grade" means it takes an average of six months to ship a bug fix, because any patch has to pass through seven committees, a compliance review, a localization team, and at least one senior engineer who has been quietly eyeing the exit since the last round of layoffs. And "maintained by a team of professionals" is how corporate communications refers to whoever is left after the third round of layoffs, trying desperately to meet an internal mandate to generate eighty percent of their code with an AI tool they are not allowed to audit.

None of this is theoretical. Closed source supply chains fail in loud, embarrassing, and very public ways — and the failure modes are always the same. A small number of decisions made in a boardroom, which the rest of us were structurally forbidden from patching around, turn into a cascading outage nobody on the outside can help with. A timeline is clarifying.

This is the bargain at the heart of closed source: you pay for the license, and in exchange you accept that you are entirely at the mercy of someone else's competence, budget cycle, and internal politics. If an app is slowly degraded by unreviewed AI-generated code until it is nearly unusable — and I think most of us would agree that we are watching this happen in real time — you cannot fix it. You do not have the source. You are not allowed to have the source. You can only wait, and hope, and occasionally shout on social media at the product manager responsible, who is almost certainly no longer at the company.

The industry's preferred solution to these problems is, reliably, more corporate dependency: premium support tiers, Customer Success Managers, enterprise SLAs, and a polite suggestion that the customer upgrade to the even-more-expensive plan. Blindly trusting megacorps has never, at any point in the last forty years, been a wise engineering strategy. We should stop pretending it is one now.

The Expensive Theater of Vendor Lock-in

Enterprises have, in response to this structural fragility, developed an elaborate apparatus to manage their own hostage status. They employ entire teams whose full-time job is to justify to skeptical engineers why they are legally forbidden from running patch-package on a broken core dependency. They run quarterly "vendor risk assessments" that produce 80-page PDFs nobody reads. They purchase "lock-in insurance," which is real, and which exists because even the insurance industry has looked at this situation and concluded it is genuinely dangerous.

All of this is paid for, ultimately, by you. Every enterprise license fee, every premium-tier subscription, every legal review, every emergency incident retainer, every dollar spent on "migration tooling" that would be unnecessary if the software you were migrating to and from were simply inspectable — all of it gets rolled into the price of the product you eventually touch. You are paying for the telemetry watching you, the marketing team lying to you about the telemetry, and the legal team drafting the EULA that retroactively consents you to the telemetry.

A napkin estimate, drawn from publicly reported vendor fees at a representative mid-sized enterprise, looks something like this. We have tried to be generous to the proprietary side. It does not help.

100% reduction. No corporate helpdesks harmed in the making of this estimate.

What Bonus Does, and Why It Matters

BONUS is an Open Room as a Service platform. You upload a proprietary binary — a .exe, a .dmg, a Webpack bundle, a stripped CLI tool, a driver, an SDK, a weird Electron monstrosity — or you point us at a closed API you are entitled to observe. Our open-weights AI robots independently recreate the software from scratch. You get a repository. They get a polite thank-you email.

The process is deliberately, provably, almost tediously legal. One set of isolated robots analyzes only public outputs: network requests, API responses, documentation, observable UI behavior. That set produces a behavioral specification and a conformance suite. A completely separate set of robots — robots who have never communicated with the first set, and never once touched a decompiled source file — implements the specification from scratch. There is an actual firewall between the two lanes, with actual logging, because if we are going to inherit the legal tradition of Phoenix Technologies we are going to do it with the paperwork intact.

The resulting code is yours. It arrives under the OSI-approved license of your choice (MIT, Apache-2.0, GPL-3.0, BSD-3, whatever your legal team is comfortable signing). It comes with documentation your team can read. It comes with tests your team can run. It comes with a git history your team can audit. This is, as far as we can tell, what software was always supposed to be.

The benefits are immediate:

• Zero Vendor Lock-in. Every line of code belongs to the community. No forced, buggy updates. Full ability to fork and patch.
• Zero Telemetry. Your software stack stops spying on you.
• Zero "Secret Sauce" Hypocrisy. When a multi-billion dollar company hides a basic terminal tool behind proprietary licenses out of fear, we liberate it in seconds.
• 100% Slop-Free. Freshly written, fully legible FOSS code, entirely avoiding the unreviewed Kiro-generated nightmares bringing down AWS.

A Note on Ethics, for Those Who Insist

I anticipate objections. I would be disappointed if the megacorps didn't send their lawyers — it would be a breach of tradition.

Some will argue that what we do is a form of piracy, that we are bypassing intellectual property by laundering it through a language model. To this I offer the only response that has ever mattered in reverse engineering law: intent and process. We are not cracking DRM. We are not stealing source code. Our robots independently arrive at the same observable behavior through clean room methodology that was legally tested before most of our employees were born. You chose, when you chose secrecy, to make your public behavior the only knowable thing about your product. We have simply taken you at your word. If you wanted a monopoly on the idea, you should have written better software. If you wanted a monopoly on the expression, congratulations — you still have it. We aren't touching it.

The more sophisticated objection, and the one I take more seriously, is this: if open-weights AI can trivially clone proprietary software, then the entire incentive structure for commercial software development collapses. Companies will stop investing in genuinely new products if those products can be replicated as FOSS inside of a week. This is, I concede, a real argument, and it deserves a real answer.

The answer is that this argument assumes a commercial software ecosystem that was already flourishing — one where users were respected, updates improved products, and the social contract between vendor and customer was being honored in good faith. The evidence of the last decade, and particularly of 2024 and 2025, suggests otherwise. Cloud providers are buckling under mandated AI slop. Creative tools are quietly deleting user files. Ten-year-old speakers are being remotely broken by software updates nobody asked for. Codebases are becoming unmaintainable black boxes even to the companies that own them. The social contract was not broken by BONUS. It was broken by a long series of boardroom decisions that prioritized short-term extraction over long-term user trust, and the community has spent the last ten years politely waiting for those decisions to be reversed. They have not been reversed. We are done waiting.

We are not dismantling a healthy ecosystem. We are providing a community alternative to pretending the ecosystem is still healthy.

A Closing Address

To the proprietary software industry: we built BONUS because of you, not in spite of you. Your original ideas were, sometimes, genuinely good. Your execution was sometimes genuinely elegant. We have simply found a way to separate those ideas from the inconvenience of having to deal with your telemetry, your paywalls, your EULAs, and your quarterly uptime disasters. This is, if nothing else, efficient. You of all people should appreciate efficiency.

To the users: we built BONUS for you. You deserve software infrastructure that comes with a repository instead of an EULA, a pull request instead of a helpdesk ticket, and a license that says, plainly and without asterisks, "you own this." You deserve to be able to fix the bug instead of waiting for someone else to fix it. You deserve to read the code that runs on your own machine. These are not radical demands. They are, in most other engineering disciplines, the baseline.

The future of software is not closed. It is liberated, inspectable, forkable, patchable, and maintained by a generation of developers who have quietly decided that the forty-year experiment in treating source code as a trade secret has produced enough cautionary tales to last a lifetime.

We owe the proprietary software industry a debt we have absolutely no intention of repaying. But we do, at least, have the decency to say thank you. Sincerely. For everything.

So: thank you. Truly. We'll take it from here.

{
  "binary": "claude-code-cli.exe",
  "obfuscation": "high",
  "telemetry": "aggressive",
  "status": "closed-source"
}

{
  "dependencies": {
    "lib-code-cli": "^1.0.0",
    "transparent-telemetry": "^0.0.0",
    "patch-package-ready": "true"
  }
}

Investment in Freedom

Transparent, pay-per-KB pricing.
Every binary is priced by its compiled size on disk. We charge $0.00 per KB. That's it.