Everyframe · Rust SDK

If it compiles, it renders.

Build video, audio and computer-vision pipelines as phantom-typed Stream graphs on the Everyframe engine. The Rust compiler rejects invalid wiring before anything runs, and every pipeline compiles to a sealed execution plan, content-addressed by SHA-256.

10 stream sorts compile-time wiring checks sealed, content-addressed plans

Prefer TypeScript?

pipeline.rs

use renderbox_sdk::{input, output};
use renderbox_sdk::ops::video::scale;

let (v, a) = input("input.mp4");
let v = v.pipe(scale(1920, 1080));

// .build() returns the sealed ExecutionPlan bytes;
// .execute().await runs it on the engine's executor.
let plan_bytes = output("output.mp4", v, a).build()?;

Invalid pipelines are compile errors

The type system carries what each stream is: its sort, and at the output, its container and codec. Whole classes of render failures never make it past your editor.

Phantom-typed streams

Every stream carries its sort in the type system. Piping video into an audio filter, or a detection stream into an encoder, fails at compile time, not at render time.

Stream<Video> Stream<Audio> Stream<Detection>

Typed expressions

FFmpeg filter expressions are built from typed variables instead of raw strings, so a typo in a timing expression is a compile error too.

Var::PTS Expr

Pure Rust end to end

No JS engine, no shell-string concatenation. The pipeline is a data structure from the first input to the sealed plan.

no shell strings no runtime eval

Ten sorts, one pipe pattern

Filters are free functions and .pipe() applies them. Same-sort filters chain; AI ops change the sort, and the types follow the data. A detection stream knows it holds detections, so only detection ops accept it.

sorts.rs

use renderbox_sdk::{input, Stream, Video, Audio};
use renderbox_sdk::ops::video::scale;
use renderbox_sdk::ops::audio::volume;

let (v, a) = input("clip.mp4");   // (Stream<Video>, Stream<Audio>)
let v = v.pipe(scale(1280, 720)); // Video -> Video
let a = a.pipe(volume(0.8));      // Audio -> Audio
// v.pipe(volume(0.5));           // compile error: sort mismatch

ai.rs

use renderbox_sdk::ops::ai::{detect, redact, RedactMode};

// AI ops change the stream sort, and the types follow.
let faces = detect(&v, "yolov8n-face");  // Stream<Detection>
let v = v.pipe(redact(faces, RedactMode::Blur { radius: 25 }));

Video Audio Detection Depth Pose Segmentation Transcript Text Scene Density

Containers that refuse the wrong codec

Codec options are constrained per container, so an impossible combination like ProRes in an MP4 is unrepresentable. Encoder settings stay typed structs, never option strings.

encode.rs

use renderbox_sdk::{output_encoded};
use renderbox_sdk::codec::{Mp4Opts, H264};

// Container-constrained codec presets: an MP4 cannot carry ProRes,
// so the type system won't let you ask for it.
output_encoded("out.mp4", v, a, Mp4Opts::H264(H264::default()));

Mp4Opts

H264, H265 or AV1.

h264 h265 av1

MovOpts

ProRes for edit-friendly masters, plus H264 and H265.

prores h264 h265

WebmOpts

VP9 or AV1 for the open web.

vp9 av1

MkvOpts

The permissive container: H264, H265, VP9 or AV1.

h264 h265 vp9 av1

The same engine, the whole toolbox

Everything the engine executes is reachable from Rust: compositing, timelines, synthetic sources and the full filter set, dispatched across FFmpeg, ONNX Runtime, OpenCV and native Rust.

combine.rs

use renderbox_sdk::ops::combine::{concat, xfade, hstack, XfadeTransition};

let combined = concat(&[v1, v2, v3]);
let faded = xfade(c1, c2, XfadeTransition::Dissolve, 1.0, 4.0);
let wall = hstack(&[left, right]);

Multi-stream ops

Concatenate, crossfade, overlay and stack any number of streams into timelines, split screens and video walls.

concat xfade overlay hstack

Timeline & Ken Burns

Assemble clips with per-cut transitions, or turn stills into a moving slideshow with Ken Burns presets.

timeline slideshow ken_burns

Synthetic sources

Start a stream without a file: solid colors, test patterns, tones and noise for slates, beds and tests.

color sine

Every build ends in a sealed plan

output(...).build() produces a sealed protobuf ExecutionPlan, content-addressed by its SHA-256 plan id. That id is what an export receipt cites, so the pipeline that ran is provable, not asserted.

The engine deep dive →

Type-check your pipelines.

Get in touch and we'll set you up with the crate, platform access and onboarding.