The Importance of Remade With Rust

The three primitives of Digital Freedom are Trust, Security, and Incentive — and none of them survive if the code underneath is not memory-safe. Every browser, every wallet, every streaming client, every codec on every phone runs on decades-old C and C++, and every year the security industry catalogs another few thousand CVEs traced back to a buffer overflow, a use-after-free, or an out-of-bounds read. That is the ambient failure rate of the software running the internet.

Remade with Rust is MATA's public initiative to replace those foundations, one rebuild at a time. Every project ships on github.com/remade-with-rust under permissive licenses — MIT, BSD, or Apache-2.0 — and every project is designed to be a drop-in safer alternative to a widely-used original. Not a fork, not a wrapper, not a fig-leaf reimplementation. A ground-up rebuild in Rust with the guarantee that whole classes of exploit never compile in the first place.

This article covers why memory-safe infrastructure matters, what Remade with Rust actually ships today, and why the whole program serves a single downstream outcome: a free internet built on distributed cloud primitives that individuals actually own. If you want the project catalog first, jump to the Remade with Rust page. If you want the philosophical frame that motivates all of this, What Is Digital Freedom covers it.

Why Memory-Safe Infrastructure Matters Now

The security research community has been counting for a long time and the numbers stay steady. Microsoft has publicly reported that around 70% of the CVEs in their products every year come from memory-safety bugs. Google publishes similar numbers for Chromium. The NIST Secure Software Development Framework has been pushing organizations to adopt memory-safe languages precisely because these are the vulnerabilities that persist across every major C/C++ codebase — the same class of bug, decade after decade.

Rust solves this at compile time. The borrow checker eliminates use-after-free by construction. Bounds-checked slices eliminate buffer overflows. The type system rules out data races. When you rebuild a codec, a database, an allocator, or a decoder in Rust, you are not writing more careful C — you are shipping a program in which whole categories of exploit will never compile. The security posture becomes deterministic instead of vigilant.

This matters because the internet is not a collection of apps — it is a stack of shared primitives that everything else depends on. A single vulnerability in libpng affects every browser, every image loader, every OS thumbnail preview. A vulnerability in FFmpeg affects every streaming service and every video conference. Rebuilding these primitives in Rust is one of the highest-leverage security investments any team can make, because a single memory-safe library removes an entire category of downstream risk across every product that adopts it. Read Era 1: Foundation of Trust for how MATA thinks about layering security up from that foundation.

What Remade With Rust Actually Ships

The Remade with Rust portfolio covers three tiers of infrastructure. At the top: the media stack — the codecs and pipelines every browser and streaming service depends on. In the middle: the foundations — the memory allocator, the UI primitives, the low-level surfaces every Rust application layers on. And beneath both: the trust layer — identity, supply-chain security, and the local-first database that keeps user data out of centralized silos. Every project below is on github.com/remade-with-rust with cards and shipping status on the Remade with Rust page.

Media Codecs Get A Memory-Safe Rebuild

The largest cluster of projects is the media stack. remade_ffmpeg_rs is a ground-up rebuild of the full FFmpeg pipeline — decode, encode, transcode, mux, probe — in pure Rust, with a drop-in-compatible CLI. Around it sits an ecosystem: rusty_h264, rusty-opus, rusty-av1-toolkit, rusty_av2d and rusty_av2f for the AV2 codec and its still-image container, rusty_jpeg, rusty_png, and rusty_dds for the texture format every game engine reaches for.

Above the codecs, the AI-media layer: FFAI bundles speech recognition (Mercury), OCR (Carmenta), and object detection (Diana) into one Rust library — no Python runtime, no ONNX shim, no C dependency in the hot path. Mercury replaces Whisper.cpp with a pure-Rust Whisper implementation. Carmenta replaces Tesseract at a fraction of the deployment footprint. Diana matches PyTorch's YOLO26 accuracy at roughly 3.7× less CPU.

Every one of these projects targets a specific C or C++ library with a long CVE history, and every one ships under a permissive license so it can be embedded in commercial products without copyleft strings. The scope is the entire media surface of the modern internet — the exact surface exploited when someone posts a malicious image, a crafted PNG, or a booby-trapped MP4. Rebuilding it in Rust removes a category of attack primitive from every downstream stack.

The Foundations Layer — Allocator, UI, Design Tokens

Below the media stack sits the foundations layer — the primitives every Rust application layers on. rusty_alloc is a memory allocator: a pure-Rust reimplementation of mimalloc's architecture that aborts on double-free instead of silently corrupting the heap. Its companion rusty_alloc_default is a tiny seam that installs rusty_alloc as the process global allocator so a whole workspace opts in from a single dependency.

Above the allocator, a UI primitives cluster: rusty_tokens for design tokens (semantic CSS custom properties with neutral defaults), rusty_symbols for Unicode glyph constants (VS15-pinned, ASCII-safe source), and rusty_a11y for ARIA HTML builders (labelled glyphs, live regions, status announcements). Together they cover the primitives every Rust UI framework — Dioxus, Leptos, Yew — needs but nobody had consolidated.

These sound less glamorous than the codecs, but they are what makes the whole stack tractable. When a memory-safe application ships in production, it depends on hundreds of small primitives — glyph constants, ARIA helpers, an allocator, a set of design tokens. If any one of those primitives has a C dependency or an unsafe hot path, the whole memory-safety story fragments. Building the foundations layer as pure Rust lets a downstream project stay pure-Rust end to end. That is the difference between "we use Rust for the important parts" and "the whole application graph is memory-safe."

Trust Primitives — Identity, Supply Chain, Data

The trust layer is where the Remade with Rust program becomes a system rather than a library collection. Sovereign ID is permissionless, self-issued identity for the web — a "Sign in with Sovereign ID" button that verifies entirely locally, no OAuth provider in the middle. mID is the Rust-side counterpart. Together they let a developer replace Auth0, Clerk, or Firebase Auth with a stack that has no infrastructure dependency and no per-monthly-active-user pricing.

Deputy is the supply-chain half: a personally-owned dependency vault that reads your Cargo.lock, fetches every crate in the transitive closure, SHA-256-verifies against the lockfile, and seals them into an encrypted local vault. Advisory scanning against RustSec, integrity/substitution detection that catches re-published versions, and offline resilience so a crates.io outage cannot stop a build. It complements Dependabot and Snyk rather than replacing them: acquire, verify, gate, then archive.

SpaceDB is the data half — a local-first, CRDT-native, mesh-replicated database that stores encrypted app data across machines near the users who own it. Per-field consistency tiers, capability-based access control, built-in vector search that keeps the corpus local. It is the database that makes local-first architectures actually workable, without either giving up on collaboration or reintroducing a central data center. See the Freedom Guide for how these trust primitives connect into a full personal-data stack.

Digital Freedom Runs On Memory-Safe Foundations

Every project in the Remade with Rust portfolio serves one downstream outcome: a version of the internet that individuals actually own. A free internet is not a slogan — it is a stack property. The freedom to run your own services, own your own identity, back up your own data, and never rent access to your own life from a company that can revoke it. Every layer of that stack has to be trustworthy, and every layer has to be inspectable by more than one auditor with commit rights to a proprietary codebase.

That is why the whole program is memory-safe, open source, and permissively licensed. Not for engineering aesthetics, but because those are the three properties that let the internet's shared primitives be jointly owned. The three subsections below trace how each layer maps to a piece of the Digital Freedom stack.

A Free Internet Built On Open Rust Primitives

A free internet needs open primitives. Not primitives you can view — primitives you can audit, fork, patch, embed, and ship without asking permission. The Rust rebuilds under Remade with Rust are all MIT, BSD-2-Clause, BSD-3-Clause, or Apache-2.0. No copyleft strings, no upstream vendor that can pull the license, no runtime fee that scales with adoption.

This matters because the alternative — proprietary or copyleft-encumbered code at the bottom of the stack — gates who can build. A startup shipping a media pipeline today has to either license from a codec vendor, accept the copyleft obligations of GPL-encoded libraries, or roll their own. A memory-safe MIT-licensed alternative removes that gate. Any developer can build on the same primitives that MATA uses to build its own products, and any organization that adopts them can inspect and modify what they run.

The Electronic Frontier Foundation has been arguing for decades that permissive open source at the infrastructure layer is a prerequisite for a genuinely free internet. Remade with Rust is the operational version of that argument: not just permissive-in-license but memory-safe-in-implementation, so the promise of "you can inspect this" comes with the guarantee that "the compiler already checked it for whole categories of exploit."

Distributed Cloud Beats Centralized Cloud

Centralized cloud is a business model as much as an architecture. The economics work by consolidating storage, compute, and identity into one vendor's data centers, then charging per-request access to the data you generated. Distributed cloud reverses that: storage lives near the user who owns it, compute happens on their devices, and identity is a keypair on their own hardware.

Remade with Rust builds the primitives that make distributed cloud actually workable. SpaceDB gives applications a local-first database with automatic CRDT convergence when replicas reconnect, so developers stop treating the network as the source of truth. Sovereign ID and mID remove the central identity provider from the sign-in path. Deputy archives dependencies locally so builds work offline. rusty_alloc and the memory-safe codec stack make it viable to run production-grade services on smaller, edge-deployed hardware.

The NIST Zero Trust Architecture guidance has been pushing organizations to stop assuming a trusted network perimeter. Distributed cloud is one architectural expression of the same idea: assume every device is its own trust boundary, encrypt everything, and share via cryptographic capabilities rather than network privilege. Rust rebuilds are what make it fast enough on the client for that architecture to feel invisible. See the Eras of Digital Freedom roadmap for how the whole thing sequences over time.

The Payoff Is Personal Digital Freedom

The user-facing outcome of memory-safe infrastructure and distributed cloud is Digital Freedom — the ability to own your data, your identity, your finances, and your relationships without renting access from anyone. Every project in the Remade with Rust portfolio contributes to that outcome by removing a dependency between an individual and a centralized service.

When your video pipeline is remade_ffmpeg_rs on your own hardware, you do not depend on a streaming service to hold your files. When your OCR is Carmenta running locally, you do not send your documents to a cloud API. When your voice recognition is Mercury, your voice notes do not leave your device. When your identity is a Sovereign ID keypair, no OAuth provider gets to see every login. When your data lives in SpaceDB on your machines, no cloud vendor gets to price your access to it.

None of those trade-offs are all-or-nothing. The whole portfolio is designed to be adopted incrementally — one rebuild at a time, one primitive at a time, until the whole application graph runs on code you can inspect and hardware you can own. That is what Digital Freedom means in practice, and it is why the Remade with Rust program matters. If you want to see the full active list of projects, the Remade with Rust page has cards for every repository with links to source, licensing, and shipping status.