A Coin for Every Project

In plain terms

Think of a tip jar that pays itself.

A popular open-source project has a hard time paying the people who fix its bugs. Money is awkward: someone has to hold it, decide who earned it, and send it — and every one of those steps is a place to argue or cheat. So mostly, nobody gets paid, and good fixes pile up unmerged.

A project coin fixes the awkward part. Anyone who wants a bug fixed puts a reward on it. Someone fixes it. The project's maintainer merges the fix — the normal thing they already do. At that exact moment, the reward is paid out automatically. No invoice, no wire, no trust me. The merge is the payment.

Who funds it

Anyone who wants the work done — a maintainer, a sponsor, a user tired of the bug. They set the reward.

Who earns it

Whoever's fix actually gets merged and stays merged. Best fix wins, not the fastest.

Who decides

The maintainer, by doing what they already do: clicking merge. That click is the whole approval.

The missing piece

Someone has to hold the keys — honestly.

Here's the catch that sinks most versions of this idea. To pay out a coin, something has to hold the power to mint it. If a person holds that power, their account can be hacked and the coin drained. If a normal server holds it, whoever runs the server can quietly pay themselves. The whole thing needs a keyholder that nobody — not even its operator — can lean on.

That keyholder is a Safebox: a sealed computer that proves what it's running, holds keys the operator can't read, and only ever does exactly what its code says. It's the trusted bridge that was always missing between "a platform said the work is good" and "the coin pays out." It launches the coin, it holds the mint keys, and it listens.

The platform decides who can act; the sealed box just listens, checks, and pays.

Why it's trustworthy

Let the platform handle who. Let the box handle the money.

The clever part is what the Safebox doesn't have to figure out. It never has to ask "is this person really a maintainer?" — because a "merged" webhook can only be fired as the result of an action GitHub itself already authorized. If the box receives it, the platform already enforced the permission. The webhook firing is the proof.

Someone funds a reward on an open issue, quoted in plain dollars so everyone knows what it's worth.
A contributor opens a fix. Tests run. The maintainer reviews it like any other pull request.
The maintainer merges. GitHub sends the Safebox a signed "merged" message.
The Safebox double-checks the message is genuine, confirms the fix really landed, and finds the contributor's wallet.
It pays out the reward in the project coin and records a bit of permanent reputation for the contributor.

The simple version

You trust GitHub to be honest about its own merges — which you already do every day. You trust the Safebox about everything after that. Nothing else, and nobody in between, gets a vote.

Not for speculation

A coin that stays spent, not hoarded.

These aren't lottery tickets. A project coin is backed by real work and real reserves, priced by what's held against what's circulating — not by a chart. Cashing out carries a tariff, and pulling out fast gets a worse rate, so the coin's job is to be used inside its community: fund the next fix, reward a contributor, tip a helper. Every project coin converts through one shared bridge currency, so any coin can reach any other.

Ordinary bounty token

Buy it, hope it goes up, dump it. Value comes from the next buyer. This is the thing that turns into a meme and crashes.

Community coin

Earn it by doing accepted work, spend it in the community, cash out with a tariff. Value comes from the work behind it.

The same idea, everywhere

Anything with a merge button — or a role — can have a coin.

GitHub is just the first example, because it has two things the whole design needs: a clear "this was accepted" event (the merge), and its own idea of who's allowed to trigger it. Any platform with those two things works the same way. The Safebox listens for the platform's "accepted" signal, trusts the platform to decide who may send it, and pays the coin. Nothing about the bridge changes — only the signal it listens for.

Qbix & other apps

Any site with webhooks or roles — a community platform, an events app, a store. "Accepted" might be an approved post, a fulfilled order, a granted role. The site enforces who; the box pays the coin.

Wikipedia articles

A coin per article. When an edit is accepted — reviewed, kept, not reverted — the editor earns the article's coin. Wikipedia already decides whose edits stick; the box just listens for the accepted revision.

Telegram channels

A coin per channel our bot is added to. The channel's admins already control who posts and who's rewarded; the bot relays those accepted events to the Safebox, which mints the channel's coin.

One trusted bridge, many platforms, a coin for each. The signal changes; the box doesn't.

The honest limits

What it takes to break it — and nothing less.

A design worth trusting should say plainly how it could fail. This one has a small, nameable attack surface, and that's the point.

The sealed box would have to be cracked. The whole thing rests on the Safebox keeping its keys and its rules sealed. That's the one dependency — and it's the exact thing the box is built and paid to defend, with a bounty on anyone who can.
Or the platform would have to lie about itself. GitHub could, in principle, forge one of its own "merged" events. But then you're trusting GitHub about GitHub — the same trust every tool built on it already extends. The box double-checks each event against the platform's own records to make even that harder.

It only works because a sealed, provable box can hold keys its own operator can't touch. That box is what was missing — and it's why these coins can be real instead of a promise. — The simple version

Which turns out to be a nice fit: the coin needs a trustworthy keyholder, and the Safebox is a keyholder whose trust is built into the hardware rather than taken on faith. The two were made for each other.