The Disco Party is MATA's distributed cloud
Everyone is trusted. Everyone brings something. Everyone leaves richer. That is what a distributed cloud actually is — and it is the opposite of the boring room you have been renting space in.
A distributed cloud is a peer-to-peer network where storage, compute, and identity live on the devices of the people using it — not in a data center owned by one vendor who can raise your prices, revoke your account, or hand your data to whoever asks first. The apps you rely on run across many small machines that trust each other cryptographically, agree on shared data through convergent replication, and pay their contributors in the same currency the network earns.
Centralized cloud is a warehouse rave with one bouncer, one bar tab, and one owner who keeps every dollar. The MATA distributed cloud is a disco party. Nobody owns the venue. Nobody owns the guest list. The speakers, the lights, the drinks, and the door are all provided by the people who showed up — and everyone who contributed shares in the upside when the party gets big. Same music, same crowd, different economics.
The rest of this page walks through the three moves that make the distributed cloud actually work, the named Remade with Rust crates underneath it, and the smallest step you can take today to join. If you want the philosophical framing first, our What Is Digital Freedom article covers why any of this matters in the first place.
The distributed cloud rests on three primitives — the same three MATA calls Trust, Security, and Incentive on every page of the site. Read them as three parts of the same party.
There is no bouncer because the door checks itself. Every guest arrives with a Sovereign ID — a cryptographic identity they generated on their own device, that other guests can verify locally without ever asking MATA. IAMHUMAN proves you are a real person; peers vouch for peers; the guest list is a math problem, not a policy decision.
The speakers, the lights, the coat check, the DJ booth — every piece of infrastructure the distributed cloud needs is provided by guests running MATA on their own devices. Idle CPU becomes edge compute. A drive with room becomes shared storage through SpaceDB. Devices that meet on the mesh sync data through iroh. What used to be a data center is now a hundred laptops and a home computer.
Contribute compute, storage, or bandwidth to the network and the network pays you back in the same currency it earns from the businesses that build on it. Refer a friend and you earn 5% for the lifetime of their usage across Banking, Cloud Services, and Small Business Services. Ownership scales with participation. The disco is not somebody else's business — it is a co-op you happen to dance at.
A metaphor is not a product. The MATA distributed cloud is a specific graph of Remade with Rust crates — each one picked because a C library, a cloud API, or a vendor SDK would put a hole in Trust, Security, or Incentive. Below is not the brochure list. It is the integration map: the problem on the mesh, the crate we drop in, and why that crate instead of the usual one.
Source lives under github.com/Remade-With-Rust. Cards, licenses, and shipping status also sit on the Remade with Rust catalog.
A distributed cloud cannot call Auth0 to ask who just walked in. That round-trip is a bouncer MATA does not own — and an outage you inherit.
Verify a guest without phoning a provider
mID verifies a Sovereign ID token entirely in-process — no JWKS fetch, no DID resolver, no MAU meter. Disco nodes, edge workers, and desktop apps all run the same check locally so the guest list is cryptography, not a SaaS policy.
github.com/Remade-With-Rust/mid↗Let a website or app ask a wallet to sign in
The browser SDK and verifier are the web face of mID. Sign-in produces a locally verified JWT; install and signup links can carry a referral code. Identity grows the party instead of taxing it.
github.com/Remade-With-Rust/sovereign-id↗Firebase assumes US-East-1 is always there. Disco peers close laptops, lose Wi-Fi, and still have to agree when they come back. Durability has to survive a kitchen, not a rack.
A database with no data center
Local-first, CRDT-native, mesh-replicated. Encrypted app data stays on hardware the user holds; replicas converge when they reconnect. Capability grants with expiry beat a standing cloud copy. Vector search keeps the corpus in the house so RAG does not become an upload.
github.com/Remade-With-Rust/spacedb↗A home drive is not a RAID array
ISA-L's Reed-Solomon, remade in Rust: GF(2^8), SIMD to GFNI, wasm-ready, no C, no GPL. Disco storage stripes shards across peers so one sleeping laptop does not lose the night. Validated parameters instead of a silent C buffer in the parity path.
github.com/Remade-With-Rust/rusty_erasure↗Mesh bandwidth is the bill you actually feel
Pure-Rust Zstandard (RFC 8878): zero dependencies, no FFI, no copyleft. Packets, vault snapshots, and codec scratch compress on the node before they cross iroh. A C zstd in the hot path would reintroduce the CVE class the rest of the stack just deleted.
github.com/Remade-With-Rust/rusty_zstd↗Office files still have to land on the mesh
libxml2 remade — parse, tree, SAX, XPath — without a C entity bomb. RAG Converter and SpaceDB ingest Word/Excel through this path so a crafted document is an error, not a heap story on a peer.
github.com/Remade-With-Rust/rusty_xml↗Disco nodes allocate hard, timestamp grants, and must still compile when crates.io is having a day. Silent double-frees and drifting clocks are how a mesh lies to itself.
mimalloc that hides a double-free until hours later
Pure-Rust mimalloc rebuild for x86-64, aarch64, wasm, and RISC-V ESP. Disco nodes (SpaceDB, codecs, FFAI tensors) hit the heap constantly. A double-free aborts instead of quietly ruining the replica. rusty_alloc_default installs it as #[global_allocator] so the whole binary agrees.
github.com/Remade-With-Rust/rusty_alloc↗Capability expiry is meaningless if the clock is a vendor daemon
chrony remade: NTPv4 + NTS client and server, Linux/macOS/Windows/wasm, no C toolchain. Mesh grants, CRDT clocks, and settlement need a time source you can audit. Disco does not rent time from someone else's chronyd.
github.com/Remade-With-Rust/rusty_time↗A crates.io outage or typosquat stops the music
Reads Cargo.lock, SHA-256-verifies the transitive closure, seals it in an encrypted local vault. Builds source from Deputy afterward. Disco firmware and host apps cannot depend on a public registry staying honest and online.
github.com/Remade-With-Rust/deputy↗Protocol JSON is on every RPC
Serde fork with rusty_alloc defaulted — measured ~54% faster, no other behavior change. Janus ALPNs and SpaceDB seams speak postcard or JSON constantly; the allocator and the JSON crate have to be the same memory-safe story.
github.com/Remade-With-Rust/rusty_json_turbo↗Thumbnails, voice, saved video, and live capture are how a home computer earns its keep. Upstream FFmpeg and x264 are the CVE farm those features used to ship.
Decode, encode, mux — without GPL C on the peer
Clean-room FFmpeg in safe Rust. Disco places files and streams; this is the pipeline that turns a camera or a library into bytes the mesh can store. Apache-2.0, embeddable, no copyleft tax on a home node.
github.com/Remade-With-Rust/remade_ffmpeg_rs↗Doorbells and saved video still speak H.264
x264 remade with forbid(unsafe_code) on the core. Bit-exact decode against ffmpeg. A doorbell that still links Cisco openh264 is a costume — Disco cameras encode and decode in the same memory-safe pipeline as the rest of the peer.
github.com/Remade-With-Rust/rusty_h264↗Newer cameras ship HEVC, not H.264
HEVC remade in Rust so a 4K doorbell does not pull libde265 or a GPL encoder. Same forbid-unsafe posture as rusty_h264: the bitstream parser that used to be the CVE farm is now a crate Disco can pin and audit.
github.com/Remade-With-Rust/rusty_h265↗Voice on a 512 KB part without libopus FFI
RFC 6716 without C. Measured ~3× on speech versus the usual FFI wrapper. Disco voice notes, Home Companion wake words, and Janus audio ALPNs stay on-device instead of hopping to a speech API.
github.com/Remade-With-Rust/rusty-opus↗Lossless rips that used to depend on libFLAC
Encodes ~17% and decodes ~23% faster than FFmpeg on the measured corpus, with smaller files. Library music on the mesh does not need a C decoder next to SpaceDB.
github.com/Remade-With-Rust/rusty_flac↗Every thumbnail is a decode
rusty_jpeg encodes 1.19× faster than FFmpeg at matched size; rusty_png decodes 2.7–2.9× faster; rusty_gif is 1.5–2.5× on the measured frames. SpaceDB thumbnails and Disco albums hit these first so a crafted JPEG is not a heap story.
github.com/Remade-With-Rust/rusty_jpeg↗The next codec generation is still a C exclusive at AOM
AV1 toolkit for embedded encode/decode. rusty_av2d is byte-identical to the AVM reference across a 45-clip corpus; rusty_av2f is the still-image container. Disco does not wait for libavm to become someone else's supply-chain problem.
github.com/Remade-With-Rust/rusty-av1-toolkit↗"Person at the door" does not require a GPU farm that keeps the clip. Era 4 only works if ASR, OCR, VLM, and YOLO run next to the sensor.
One AI media surface instead of a Python archipelago
ASR, TTS, OCR, VLM, YOLO in one Rust library. Disco Home Companions call FFAI on-device so the hallway is not a training set. Optional GPU; CPU-only still compiles; WASM when the edge is the tab. Mercury, Carmenta, and Diana are the engines underneath.
github.com/Remade-With-Rust/FFAI↗Whisper.cpp is still a C++ tree with a Python wrapper
Speech-to-text remade in Rust. A voice note or a wake word on a Disco peer transcribes in process. No upload to a vendor ASR, no ggml C blobs next to the wallet.
github.com/Remade-With-Rust/mercury↗Tesseract and cloud OCR both leave the page
OCR in about 4.7 MB of detector weights. Receipts, IDs, and screenshots stay on the device that photographed them. RAG Converter uses this path so a PDF never has to visit someone else's GPU.
github.com/Remade-With-Rust/carmenta↗Ultralytics YOLO is a Python+CUDA lifestyle
YOLO26 at a fraction of Ultralytics' RAM with matching mAP. "Person at the door" is a local tensor, not a clip in a vendor archive. Disco cameras answer to the house.
github.com/Remade-With-Rust/diana↗A party of only laptops dies when the lid closes. Hardware has to join as a peer. Play has to be a stream you host, not a region you rent.
esp32 iroh instead of aws-iot-device-sdk
An iroh endpoint on ESP32 (std/ESP-IDF), Janus ALPNs for rpc, media, and telemetry, plus a bridge that fronts no_std nodes. Bare parts stay LAN-direct; PSRAM boards take relay. The doorbell joins the Disco Party as a peer, not a leased sensor. The keyword is esp32 iroh; the crate is rusty_esp_iroh.
github.com/Remade-With-Rust/rusty_esp_iroh↗Factory OS that still ships aws-iot-device-sdk
One binary a hardware maker drops onto the OS they already ship: mID identity, an honest catalog, optional FFAI engines. The board wakes into the Disco Party instead of a vendor cloud SKU. Pairs with the Janus doorway on the Freedom Guide makers tab.
github.com/Remade-With-Rust/mata-oem-sidecar↗GameStream clients written in a decade of C++
Moonlight remade — RTP, decode, input — so a game PC is a disco peer, not a product you rent back. Same codecs as the rest of the stack (rusty_h264, remade_ffmpeg_rs). Comet (proprietary) is the matching hardware-encode host.
github.com/Remade-With-Rust/starfire↗GPU textures still go through DirectXTex
Pure-Rust DDS container, decode, encode, and GPU upload plans. Game assets and Disco media that land as textures do not need another C parser on the host. Built to power the play side of the party.
github.com/Remade-With-Rust/rusty_dds↗This is the plumbing the disco party runs on — and none of it depends on a data center that could shut the venue down. Browse every card on Remade with Rust or the org at github.com/Remade-With-Rust.
The party is already running. The MATA Freedom Guide walks you through the smallest set of steps that gets you inside the door — sign up, install the extension, connect one bank, import your passwords, invite a friend to back up your vault. From there, participation scales as far as you want.
