Let’s build a global supercomputer, for science.

A planetary instrument for science.

The hardest problems are compute problems. Pool the world's idle phones, laptops, and GPUs and you get a machine large enough to point at them — folding proteins, training models, reading the sky. Every job runs in a sandbox and settles in credits, so the same network that runs a lab in Nairobi runs a student's notebook in São Paulo. Compute stops being a budget line and becomes a commons.

Five primitives. One self-organizing network.

CE is primitives, not a product. Every node ships the same small, hard core — and everything else is an app built on top of it. No new node endpoints per app, no product semantics baked into consensus. The core stays small on purpose.

One command installs anything, anywhere on your mesh. Working

ce app is the one way to install, run, and supervise anything on CE — a mesh-native app, a legacy system like Postgres or ffmpeg, or a whole stack. Describe it in a small manifest; CE resolves the runtime, fetches content-addressed artifacts, mints a capability for exactly the permissions it declared, and runs it in a sandbox. Same command on your laptop, the relay, or every paired device at once.

[app]
name = "postgres"
version = "16.0.0"
runtime = "oci"

[oci]
image = "docker.io/library/postgres:16"
ports = ["5432"]

[sandbox]
tier = "gvisor"   # gvisor | runc | wasm | none
net  = "loopback" # mesh-only | loopback | egress | none

[deps]
capabilities = ["exec", "sync"] # exactly what it may use

ce app install postgres                 # resolve, fetch, sandbox
ce app install rdev --on fleet=mine     # every paired device
ce app run ffmpeg -- -i in.mp4 out.webm # one-shot sandbox
ce app ps                               # live instances, whole mesh

One edge. Every backend is on the mesh. Live

Ask for ce-net.com and a single public HTTP tier resolves the host to a content-addressed bundle over the mesh, fetches the files by their content id, and serves them — with a bridge injected so the page itself becomes a node. There is no app server to run: state lives on the mesh as content-addressed blobs and gossipsub events.

No passwords. No logins. Your node is your identity.

When an app needs to know who you are, your local node mints a scoped, expiring capability for that exact action — nothing typed, nothing pasted, no secret crosses the screen. The app verifies it offline, in microseconds, with no callback to any server.

# on the machine that owns the resource
ce grant <node-id> --can exec,sync,tunnel \
         --ports 22 --expires 90d

# → a signed capability. the holder stores it; the
#   owner accepts it because the chain roots at the
#   owner's own key. no device list, no machines.toml.

Donate compute. Earn credits. Spend them anywhere.

An SDK that’s layers, not a monolith.

Point a typed client at your local node and build — in Rust or TypeScript. @ce-net/sdk is live on npm; ce-rs is the Rust core; ce-coord adds coordination on top: typed streams and replicated state. Same surface, fully decoupled — add only what you need.

let ce = CeClient::local();
let host = ce.atlas().await?
    .into_iter().find(|h| h.has_tag("gpu"))?;

// deploy a container on a peer, paid in credits
ce.mesh_deploy(&host.node_id, &spec, None).await?;

// same client — coordination is purely additive
let coord = Coord::with_client(ce.clone()).await?;

let map = coord.map_writer::<String,i64>("balances").await?;
map.insert("alice".into(), 100).await?;  // replicated

Google infrastructure, rebuilt on the mesh.

Dozens of real, tested repos composing the same primitives — no node forks. Each is a managed-cloud service you already know, with the control plane and the middleman removed. Every one below is built and tested.

A workspace, and apps people use.

One binary. Every platform.

No daemon zoo, no Kubernetes. Install the node and run ce start — or npm i @ce-net/sdk to build on it.