remade_ffmpeg_rs — A Pure-Rust Media Pipeline That Replaces FFmpeg

FFmpeg is the media operating system of the internet. Decode, encode, transcode, mux, probe — every browser, every editor, every streaming client, every "just convert this file" script sits on that C codebase. It is also a CVE factory. A single crafted container is every thumbnailer and every call stack that linked libavformat.

remade_ffmpeg_rs is FFmpeg remade in Rust: a memory-safe media pipeline for embedded encode and decode, with no C toolchain in the build. It powers FFAI and MATA Disco Party. Around it sit the codec crates — rusty_h264, rusty-opus, rusty_flac, rusty_jpeg, rusty_png — so the pipeline is not a facade over libavcodec. The catalog is Remade with Rust. The thesis is rebuilding the foundation of the internet. This article is the pipeline.

Why remade_ffmpeg_rs Replaces A Memory-Safe Media Pipeline Gap

There was no memory-safe media pipeline that spoke the formats the internet already uses. Bindings to FFmpeg added a Rust handshake in front of the same heap. Electron apps shelled out to a system binary. Cloud APIs took the file and called it "processing." None of those satisfy the NIST Secure Software Development Framework push toward memory-safe languages, and none of them compile to WASM without a miracle.

remade_ffmpeg_rs is FFmpeg remade in Rust so the hot path is Rust. A memory-safe media pipeline means demux and decode refuse use-after-free at compile time. That is the product. Wrapping libavcodec is not the product.

Trust, Security, and Incentive fail when media is the exception. Trust fails when the voice note boarded a transcoder you do not run. Security fails when the container parser is still C. Incentive fails when the safer path is slower, proprietary, or GPL-encumbered. remade_ffmpeg_rs is how those three primitives apply to bytes that used to be "somebody else's problem."

What remade_ffmpeg_rs Ships As FFmpeg Remade In Rust

github.com/Remade-With-Rust/remade_ffmpeg_rs is the source. The job is the FFmpeg job: open the file, understand the streams, convert, write, probe. Embedded is a constraint, not a vibe — the same binary has to make sense on a mesh node and in a browser tab.

remade_ffmpeg_rs As The Memory-Safe Media Pipeline

Decode, encode, transcode, mux, probe. remade_ffmpeg_rs is the facade crate (rff by git URL — the crates.io rff is a different project). A memory-safe media pipeline is useless if it only does one codec. FFmpeg remade in Rust has to speak the formats people already have: H.264, Opus, FLAC, JPEG, PNG, the containers those live in.

This is the stage before any model runs. AI on the edge starts with demux. Mercury cannot hear a room if the audio never left the container. remade_ffmpeg_rs is that stage.

Codecs Around remade_ffmpeg_rs — H.264, Opus, FLAC, JPEG, PNG

The pipeline is honest only if the codecs are remakes too. rusty_h264 is H.264 remade in Rust. rusty-opus is the audio call codec. rusty_flac is lossless audio. rusty_jpeg and rusty_png are the image stack. Those crates are siblings, not optional FFI. FFmpeg remade in Rust that still dlopens libx264 is a press release.

Builders pick the surface they need. Need pixels only? Pull the codec. Need a memory-safe media pipeline? Pull remade_ffmpeg_rs. Need ASR, OCR, and detection on the same graph? That is FFAI, with remade_ffmpeg_rs underneath.

FFAI And Disco Party Run remade_ffmpeg_rs

FFAI is the AI-media library: Mercury for speech, Carmenta for OCR, Diana for detection, on one Candle backbone. It does not shell out to a system FFmpeg. It runs remade_ffmpeg_rs. Disco Party is the mesh. Media on that mesh is a placement problem and a codec problem. remade_ffmpeg_rs is how FFmpeg remade in Rust becomes a node capability instead of a region in us-east-1.

The Federal Trade Commission keeps catching products that collected more than they needed "to make the feature work." A memory-safe media pipeline that never leaves the device shrinks that surface by architecture.

How remade_ffmpeg_rs Feeds Digital Freedom

Digital Freedom is ownership. A vault that transcodes in a vendor cloud is a contradiction with extra steps. remade_ffmpeg_rs is how FFmpeg remade in Rust keeps the file on hardware you hold.

Trust The File, Secure The Container

Trust is a file that stayed yours. Security is a memory-safe media pipeline — compile-time refusal of the overflow class in parsers that touch untrusted bytes. Incentive is a crate you can embed without a vendor license. The EFF has argued for decades that a free internet needs infrastructure you can inspect and run. remade_ffmpeg_rs is that argument applied to every MP4.

The NIST Zero Trust Architecture tells operators to stop trusting the perimeter. remade_ffmpeg_rs is how you stop trusting the demuxer as well.

Distributed Cloud Media Without A C Toolchain

A distributed cloud node has no apt-get install ffmpeg. WASM has no C toolchain at all. remade_ffmpeg_rs is FFmpeg remade in Rust so both targets still build. Deputy vaults the crates so the pipeline's supply chain is yours. The Freedom Guide is the personal-data path; this crate is why a voice note or a home video does not secretly need a transcoder farm.

Era 1 stores the file. Era 4 records it. remade_ffmpeg_rs sits under both.

The Catalog Entry For remade_ffmpeg_rs

Source is github.com/Remade-With-Rust/remade_ffmpeg_rs. Cards, licenses, and shipping status live on the Remade with Rust catalog. The mesh this pipeline feeds is the Disco Party and what a distributed cloud is. Digital Freedom is Trust, Security, and Incentive as a sequence.

If you came from the Learn index looking for a memory-safe media pipeline, this is the crate. If you came from FFmpeg, this is the remake. Depend on it by git. The internet you want to own still speaks containers. remade_ffmpeg_rs is how that sentence stays true without the C.

H.264 inside this pipeline is rusty_h264. The image codecs beside it are rusty_png and rusty_jpeg. A product that consumes the pipeline without a cloud encoder is Starfire and Comet.