A while back, I said I wanted to build a replacement for GitHub.
The important realization was that I did not need to build another GitHub.
Git already distributes the code.
What it does not distribute is the collaboration around the code.
Issues. Reviews. CI results. Decisions. Governance. Identity. Agent memory.
That part is still usually trapped inside somebody else’s service.
So I built Hubnot.
Small naming footnote: this project originally had a different name. My European friends very kindly pointed out that it carried some unintended baggage in a few languages, so I took the hint and renamed it before shipping. Oops, my bad. (This is why creative naming is a bad idea). 😅
https://github.com/LynnColeArt/hubnot
Signed facts in Git
Hubnot distributes collaboration with the Git repository itself.
There is no Hubnot server.
There is no Hubnot database.
There is no SaaS account that owns the project state.
An ordinary Git remote carries both the code and the signed collaboration facts stored under refs/hn/*.
That means proposals, reviews, CI requests and results, governance decisions, merge facts, device identities, policy amendments, and deliberate agent memory can all travel with the repository.
And they are signed.
The protocol is designed around immutable facts rather than mutable website state.
A review says, “this actor approved this exact proposal.”
A CI result says, “this runner tested this exact candidate.”
A decision says, “this maintainer accepted this exact revision under this policy.”
If the proposal changes, the old evidence does not magically apply to the new one.
You create a new revision and gather new evidence.
That sounds obvious when you say it out loud.
But it is not how most software collaboration systems are modeled.
The operational alpha
Hubnot has now crossed its first important milestone: the operational alpha is complete.
More importantly, Hubnot has used its own protocol to revise, independently sandbox-test, approve, accept, and merge changes into its own public main branch.
So yes, it has already started eating its own dog food.
Or possibly its own Git objects.
The project is still alpha. The protocol is not stable yet, and there is plenty left to build.
But the core idea works.
Git already gave us distributed version control.
Hubnot is an experiment in finishing the job.
Code should not be the only part of software collaboration that belongs to the people doing the work.
MIT licensed.
Yours to clone, break, improve, argue with, and build on.
Now go forth you beautiful little being of light, and break something!