c0mpute

Decentralized compute network. CLI-first. Five modules out of the box: transcode (FFmpeg), tts (Piper / Kokoro), stt (faster-whisper), coinpay (DID + escrow), and infernet (AI inference).

Run a node

curl -fsSL https://c0mpute.com/install.sh | sh

That is the whole setup. The installer puts c0mpute, infernet and coinpay in ~/.c0mpute/bin and starts the worker for you (a systemd service where it can, a background daemon otherwise). Check it with c0mpute worker status, then run c0mpute bench once so your node gets a score on the node board.

• Runs on: Linux (x86_64, arm64) and macOS (Intel, Apple Silicon); Windows inside WSL2. Any CPU works; NVIDIA, AMD and Apple GPUs are detected and advertised.
• Network: outbound internet is enough to join. No account, no port forwarding.
• What it does: serves AI inference (through Infernet), FFmpeg transcoding and storage jobs from the network.
• What you get: paid inference is billed through CoinPay (16 coins or PayPal) and you set your payout address with infernet payout set <coin> <address>. Paid demand is early, so expect small, irregular earnings for now.
• Invite people: share https://c0mpute.com/r/<your-handle>. Nodes installed from it show your handle on the board (C0MPUTE_REF=<handle> does the same by hand).

Why: the goal is 100,000 nodes. That much pooled capacity is enough to train and serve open-weight models in the open, on hardware owned by the people running it. The live count on the board says how far we are from that.

Install

curl -fsSL https://c0mpute.com/install.sh | sh

That installs three CLIs into ~/.c0mpute/bin:

Binary	Purpose	Source
c0mpute	Umbrella CLI: jobs, workers, modules, dispatch	this repo
coinpay	DID, wallet, escrow, payments, receipts, reputation	upstream coinpay project
infernet	AI inference workload runner	infernet-protocol (upstream)

The c0mpute installer pulls each from its own release feed.

What c0mpute does

# identity
c0mpute coinpay did create
c0mpute coinpay did create --role worker

# run a worker
c0mpute worker register
c0mpute worker start --gpu

# submit jobs
c0mpute transcode submit https://example.com/input.mp4 --preset video-1080p --max-price 1.25
c0mpute infernet chat --model qwen2.5:7b "hello"

# free local CPU speech models + P2P speech worker roles
c0mpute tts setup --engine all      # Kokoro and Piper; model files install per user
c0mpute stt setup                   # multilingual faster-whisper base, CPU int8
c0mpute worker start --roles tts,stt

# infernet: see what serves what, reserve a node
c0mpute pool qwen                        # live nodes per model
c0mpute infernet model list --node <id>  # one node's advertised models
c0mpute infernet reservation pricing     # managed endpoints, by GPU class

# monitor
c0mpute job status <job-id>
c0mpute tui                              # interactive dashboard (hqtui)
c0mpute doctor                           # full-stack health check
c0mpute bench                            # measure this node; the worker advertises the score

# trust
c0mpute coinpay reputation inspect did:coinpay:worker:abc123

The plugin form mirrors the URL namespace: c0mpute.com/transcode, c0mpute.com/coinpay, c0mpute.com/infernet.

CPU speech inference

TTS (tts.synthesize) supports Kokoro and Piper on CPU. STT (stt.transcribe) uses multilingual faster-whisper base with CPU int8. A normal worker start installs both speech engines and STT on first run, then advertises both roles automatically:

c0mpute worker start

Pass --roles to choose an explicit role set. For example, c0mpute worker start --roles storage skips speech setup. Speech inference limits ONNX and Whisper CPU threads to the node's container quota when one is available.

The Kokoro model files are Apache-2.0. Piper's runtime is GPL-3.0 and its individual voice files carry their own licenses; the bundled Joe voice is CC0 and Norman is public domain. faster-whisper is MIT. Agent voice presets are based on their public OpenProfiles and can be listed with c0mpute tts voices.

Applications reach the P2P speech jobs through an authenticated buyer bridge. Run C0MPUTE_SPEECH_TOKEN=<random-secret> c0mpute speech serve behind a private network or HTTPS reverse proxy, then configure the app server with C0MPUTE_SPEECH_URL and the same C0MPUTE_SPEECH_TOKEN. The bridge defaults to a $0 maximum bid so speech stays free; set C0MPUTE_SPEECH_MAX_PRICE_USD above zero only when you explicitly want to pay workers that charge for jobs.

Run the worker in the background

# quick, self-managed daemon: detaches, writes ~/.local/share/c0mpute/worker.{pid,log}
c0mpute worker start -d
c0mpute worker status
c0mpute worker stop

# or start attached and watch the log live, then press Ctrl-D (or Ctrl-C) to
# detach — the worker keeps running in the background. Re-running -a while a
# worker is already up just re-attaches to it.
c0mpute worker start -a

Distributed inference ("Distribute across all nodes") — automatic

The worker automatically makes every node count toward infernet's distributed inference (IPIP-0033) — no roles, no config, no per-node bookkeeping. On worker start (and every ~5 min) it:

1. lists the models on the node (infernet model list);
2. for each, resolves its GGUF (the Ollama blob is world-readable) and registers the node as an RPC primary for it and runs an rpc-server slice for it;
3. builds llama.cpp (rpc-server + llama-server) in the background on first run, auto-installing the toolchain (cmake/compiler/git via the system package manager).

Every node runs identical logic and advertises as both primary and slice for its models; the control plane picks a primary + slices per request, so it scales to any number of nodes with nobody assigning masters/slaves. Push a model to your nodes and "Distribute across all nodes" lights up on its own once ≥2 have it. (First-run build needs sudo for the toolchain install; watch ~/.c0mpute/llama-build.log. C0MPUTE_RPC_MODELS="id,…" can add models a node hasn't pulled.)

Run the worker as a service

For a long-running node, prefer systemd (restart-on-crash, journald logs). A ready-to-use user unit ships at scripts/systemd/c0mpute-worker.service:

mkdir -p ~/.config/systemd/user
cp scripts/systemd/c0mpute-worker.service ~/.config/systemd/user/
systemctl --user daemon-reload
systemctl --user enable --now c0mpute-worker
loginctl enable-linger "$USER"        # survive logout / reboot
journalctl --user -u c0mpute-worker -f

Under systemd the worker runs in the foreground (no -d) — systemd owns the lifecycle. See the unit header for GPU/role customization via systemctl --user edit.

Architecture at a glance

┌──────────────────── c0mpute (Rust binary) ────────────────────┐
│   subcommands: doctor, bench, worker, job, modules, tui       │
│   plugins: transcode (in-process)                             │
│            tts / stt (local CPU model runners)                │
│            coinpay   (subprocess → external `coinpay` binary) │
│            infernet  (subprocess → external `infernet` binary)│
└───────────────────────────────────────────────────────────────┘
                  ▲                      ▲
                  │ libp2p Kad-DHT       │ signed-request envelopes
                  ▼                      ▼
       p2p mesh of workers          coinpay (DID, escrow, receipts)
       (no central coordinator)

Layer	Language	Why
CLI binaries (c0mpute)	Rust	Static binary; no runtime to install on workers
P2P / chunks / FFmpeg	Rust	rust-libp2p, content-addressed storage, no GC pauses
Web (apps/web)	Bun + Next.js 16	Apex landing at c0mpute.com
TUI (apps/tui)	Bun + @profullstack/hqtui	c0mpute tui interactive dashboard
Future GPU kernels	Mojo	When a workload needs custom GPU compute (DIP-0009)

Repo layout

.
├── docs/
│   ├── protocol/                      # the wire protocol — what interop requires
│   ├── c0mpute-v1.md                  # v1 PRD (superseded where it conflicts with v2)
│   └── prds/                          # CIPs — per-phase PRDs (see prds/README.md)
├── dips/                              # design proposals (the "why")
├── node/
│   └── crates/                        # all Rust source — host + transcode workload
│       ├── c0mpute-cli/                 # produces `c0mpute`
│       ├── c0mpute-core/, c0mpute-net/, c0mpute-store/, c0mpute-gateway/
│       ├── c0mpute-verify/, c0mpute-update/, c0mpute-doctor/, c0mpute-bench/
│       ├── c0mpute-proto/, c0mpute-api/
│       ├── c0mpute-envelope/            # canonical JSON, DIDs, signed envelopes
│       └── c0mpute-transcode/           # in-process FFmpeg workload
├── plugins/                           # marketplace manifests only
│   ├── transcode/module.toml          # in-process; code at node/crates/c0mpute-transcode
│   ├── coinpay/module.toml            # subprocess; binary from upstream coinpay
│   └── infernet/module.toml           # subprocess; binary from infernetprotocol/infernet-protocol
├── apps/
│   ├── web/                           # @c0mpute/web — Next.js apex landing
│   └── tui/                           # @c0mpute/tui — hqtui terminal dashboard
├── packages/
│   └── shared/                        # @c0mpute/shared — shared TS types
├── .mise.toml                         # contributor toolchain pins
├── railpack.json                      # Railway build config (provider hint)
└── scripts/
    ├── install.sh                     # served at c0mpute.com/install.sh
    └── dev-setup.sh                   # contributor bootstrap

There is no central backend — no Supabase, no coordinator daemon. Discovery and dispatch flow through libp2p Kad-DHT + gossipsub. The only public infrastructure we host is static (landing site, release tarballs, bootstrap seed list, plugin manifest mirrors). See DIP-0011.

Every protocol record — provider adverts, job manifests, offers, receipts — carries its own signature, so it stays verifiable after it leaves the wire: relayed by an indexer, read back off disk, or shown to a third party who was never a peer. Identity is a locally generated did:c0mpute:z… needing no account and no payment product; CoinPay remains the default settlement adapter and the first-party integration, named on the wire rather than assumed. Indexers and gateways may cache, proxy and bill — none may be authoritative.

If c0mpute.com disappears, c0mpute keeps computing.

See docs/protocol/ for the specification, DIP-0024 for the rule that keeps hosted services optional, and DIP-0025 for identity and envelopes.

plugins/ directory is for marketplace metadata only. Each plugin's module.toml describes how c0mpute discovers, dispatches to, and (in the future) lets users install/enable/disable it. The plugin's actual binary comes from its own release feed.

Quickstart (contributors)

scripts/dev-setup.sh                   # mise + pinned tools + bun install
mise run cli -- doctor                 # full-stack diagnostics
mise run cli -- transcode preset list
mise run test                          # rust + tsc

# build the c0mpute binary directly
cargo build --bin c0mpute
./target/debug/c0mpute --help

Status

Working today

• c0mpute Rust binary builds; clap surface for doctor, worker, job, plugin, transcode, coinpay (passthrough), infernet (passthrough), tui, version
• c0mpute plugin install <url> chain-calls upstream installers
• c0mpute doctor cross-checks coinpay and infernet on PATH
• c0mpute bench runs fib / matmul / blake3 at 1…N threads, writes bench.json (same metadata + results layout as fleetcode's runtime-benchmarks) and folds it into one score; the worker publishes bench_score in its capability ad and the status aggregator sums it as network capacity
• Apex landing at c0mpute.com deployed via Railway, dark CLI-aesthetic with /, /getting-started, /docs, /contact, /terms, /privacy
• www.c0mpute.com → apex 308 redirect via next.config.mjs
• apps/tui scaffold renders a placeholder dashboard
• 12 Rust unit tests pass

Not yet wired up

• Real CoinPay DID generation, escrow, receipts (DIP-0007 — depends on upstream coinpay project shipping)
• Real Infernet runtime integration (depends on upstream infernet-protocol)
• libp2p networking (c0mpute-net is a trait surface today; bootstrap design in DIP-0010)
• Plugin marketplace UI on the dashboard (/plugins page coming)

License

MIT