Turn code merges into
sustainable open-source funding

Four stages, one boundary that matters

Everything that decides who gets what happens offline and deterministically. Only the last stage touches the outside world.

Where a round goes

Cut in a fixed order, off the top, with the numbers under your control.

And what a project becomes

Funding accumulates. Crossing a threshold you set changes what the project is allowed to do — and the ladder only goes up.

Thresholds are configuration, not constants — a project that names none stays in the first stage, which is a perfectly good way to use this. The rules are ordinary Rust and proved rather than promised: raising more never lowers the stage, and the four slices sum to exactly what was harvested. None of it is wired to a chain yet.

What the code guarantees

Not claims — gates. Each of these is held down by property tests that hammer it with thousands of generated rounds.

Install

Every archive ships a SHA-256 checksum and signed build provenance. The installer refuses to run without verifying the checksum first.

curl -fsSL https://raw.githubusercontent.com/\
dedalo-org/dedalo/main/install.sh | sh

cargo install dedalo --locked
# or, without compiling:
cargo binstall dedalo

Or run it in CI

A payout belongs in the pipeline that merged the code.

- uses: actions/checkout@v5
  with:
    fetch-depth: 0        # attribution needs the full history

- uses: dedalo-org/dedalo@v0
  with:
    command: plan
    amount: "1000"

Read before you trust it

Two places, and the split is deliberate. The handbook is written; the API reference is generated per released version, so it matches the crate you installed rather than whatever main looked like this morning.

quickstart          a round in ten minutes
money              integers, and what is proved
dedalo.toml        every key, every default
verification       proved vs. merely tested
threat model       who could make it pay wrong
auditing           check a project yourself

# signatures and types, per release
docs.rs/dedalo

# the library, without the CLI
[dependencies]
dedalo = { version = "0.1",
           default-features = false }

Project status

What has actually shipped

Generated from the project’s changelog at build time, and rebuilt on a schedule — so this is what the repository says, not what somebody remembered to update here.

1. Unreleasednot released

   • core: the git → attribution → payout plan → settlement pipeline, with the first three stages pure and offline so a plan is reproducible from history.
   • core: integer-only money (Amount), largest-remainder splitting that conserves every base unit, and a fee schedule in basis points that rounds down in the contributors' favour.
   • core: content-addressed payout plans, an append-only ledger, and refusal to settle the same plan twice.
   • cli: dedalo init, scan, contributors, plan, settle, status, identity, propose and ledger, each with --json.
   • git: [git] lands_as decides what counts as a landed change — a merge commit, or every commit on the branch's first-parent line. A squash-merge repository produces no merge commits at all, so the previous behaviour paid for nothing on the default setting of most projects.
   • chain: the chain is Solana. Addresses are base58 over thirty-two bytes, Merkle leaves are sha256 over packed little-endian fields, and instruction data is Borsh. dedalo propose prints the accounts an instruction takes as well as its data.
   • and 4 more in the changelog

2. 0.0.02026-08-25

   • crate: a placeholder published to crates.io so that dedalo could not be taken while the tool was being built. It had no library surface and no dependencies; the binary answered --version and otherwise printed where the code was.
   • Nothing in it computed, moved or recorded money.
   • Publishing an empty version rather than the work in progress was deliberate. A version can be yanked but never withdrawn, so the first number that carries code should be one somebody can rely on. That number is 0.0.1.
   • It was cut from a branch that no longer exists. For six days main held the placeholder and the code lived on v0.1; the arrangement cost more than it bought — Closes #N never fired, cargo install --git installed a binary with no subcommands — and the code came back to main.

The full changelog is in the repository, and this is generated from it.

What else is here

Everything in the organisation is open source and MIT licensed.

The protocol: attribution, payout plans,
the hash-chained ledger, the claim contract,
and the CLI and GitHub Action that drive them.

rust · handbook · api · source

Attribution where the code is. Shows who
earns from the lines in front of you, read
from the same history a payout comes from.

lua · early · source

Contributing pays

Dedalo is open source, MIT licensed, and built by the community. If you care about Rust, developer tooling and sustainable open-source economics, contributions are welcome — and they are literally what the project pays out for.

Or fund it

A project whose subject is transparent funding should be transparently funded, so the collective's ledger is public — where the money went is a page you can read rather than a claim.

Sponsoring is all it is. Dedalo does not integrate with Open Collective and is not going to: what it is built on is git, Solana, Rust and formal verification, and a fifth dependency that has to be true about a contributor's project would be a fifth thing to keep true.