Let's be real. Most of the software that runs modern teams – your CMS, your design tools, your communication apps – is closed source. And for a long time, that was fine. Software was expensive to build, and the people who built it deserved to make money.

But something has changed. Software quality is visibly going to hell in slow motion, and the most frustrating part is: you can't do anything about it.

Every update is a roll of the dice. Will it be better? Worse? Will the feature your workflow depends on quietly break? You don't know, because you can't look at the code. You can't fix it. You can't fork it. You're just stuck, hoping the team cares enough to get it right.

The AI era has made this dramatically worse. Teams are shipping faster than ever – but faster isn't better if nobody's accountable to the quality of what gets shipped. Closed source in the AI era means the slop compounds in silence, and you only find out when the thing stops working.

We refuse to build that kind of product.

There's something that shifts when you open source something meaningful. Suddenly, you can't hide behind vague roadmaps or "we're working on it." The code is right there. Your users can read it, fork it, and call you out publicly when it goes in the wrong direction.

That accountability is exactly what we want.

When b10cks takes a wrong turn – and every project eventually does – you're not waiting for us to prioritize your problem on some internal backlog. You can look at the code, understand what's happening, and fix it. You can submit a PR. You can fork and go your own direction. Or you can just show us working code that proves your solution is better.

That's how software should work. That's how b10cks works.

There's a mindset shift that separates great engineers from good ones. Great engineers don't accept arbitrary boundaries in the systems they work with. When something doesn't work the way they need, they don't build workarounds. They go to the source and fix it.

Closed-source software makes that impossible. You hit a wall, and the wall is real. You can't go around it. You have to work around it, live with it, or leave the tool entirely.

Open-source removes the walls. When b10cks does something that doesn't fit your needs, you're not at the mercy of our sprint planning. You have the source. You can understand it, modify it, patch it, and run your patched version in production today.

I built b10cks open source because we believe the developers who use it deserve to work this way, and because I wanted to live with the same accountability.

I've seen what "open source" sometimes means in the wild: a free tier that covers nothing, a public repo with no meaningful code in it, or a license that's open source right up until someone actually wants to use it commercially.

b10cks is licensed under the GNU Affero General Public License v3. Here's what that actually means for you:

You can self-host it. Forever. No permission needed, no license key, no call with our sales team. Clone the repo, run Docker, done.

You can read every line of code. The whole product. No obfuscated bundles, no closed-core with an open-source wrapper. The thing you use is the thing that's on GitHub.

You can fork it. If we make decisions you disagree with, you can take the project in your own direction. If you improve it, you contribute those improvements back. That's the deal – and it's a fair one.

The AGPL closes the cloud loophole. Some companies open source their code knowing that nobody can really compete with their managed service anyway. The AGPL means that if someone builds a business on top of b10cks, those modifications stay open. The community that built this stays protected.

We make our money by running a great hosted product. Not by locking you into it.

Here's the uncomfortable truth about AI-assisted development: it amplifies existing incentives. Teams that prioritize quality will ship better quality faster. Teams that prioritize shipping will ship slop faster.

In a closed source environment, you have no way to know which one you're dealing with until the damage is done. You can't audit the codebase. You can't see what got merged without review. You can't track the ratio of thoughtful architecture to AI-generated patches that nobody fully understood.

Open source is the answer to this. The code is visible. The commit history is visible. The PRs, the reviews, the discussions – all of it is in the open. If b10cks ever starts shipping slop, you'll see it before you feel it. And you'll have the tools to do something about it.

At Coders Cantina, we've staked our reputation on building technology that genuinely serves the people who use it – not technology that optimizes for retention metrics at the expense of quality. Open source is how we prove that commitment rather than just assert it.

Some people hear "open source" and assume it means unsustainable, or a venture-backed giveaway that eventually ends in a pivot or a license change. We've seen that story too.

b10cks is built on a straightforward model: the software is free and open. The managed hosting – the convenience of not running infrastructure – is what we charge for. That's it. Storage and traffic. No per-seat fees. No feature tiers. No upsells.

This works because the people who run their own infrastructure will do exactly that. The people who want a reliable, well-maintained hosted product will pay a fair price for it. And the quality of the hosted product is kept honest by the fact that the self-hosted alternative is always one git clone away.

We're not the first to try this model. We're just the ones building the CMS your team actually needs – with the conviction that the right way to build software is the only way we want to build it.