Crate parallax 

Parallax

A Rust-native streaming pipeline engine with zero-copy multi-process support.

Parallax provides both dynamic (runtime-configured) and typed (compile-time safe) pipeline construction, with buffers backed by shared memory for efficient multi-process communication.

Features

• Zero-copy buffers: memfd-backed arenas with cross-process reference counting
• Progressive typing: Start dynamic, graduate to typed
• Multi-process pipelines: memfd + Unix socket IPC (SCM_RIGHTS)
• Hybrid scheduling: Tokio tasks + dedicated real-time threads
• rkyv serialization: Zero-copy deserialization at network boundaries
• Linux-only: memfd_create, huge pages, eventfd, DMA-BUF

Quick Start

use parallax::prelude::*;
use parallax::typed::{pipeline, from_iter, map, filter, collect};

// Dynamic pipeline (string syntax)
let mut pipeline = Pipeline::parse("videotestsrc num-buffers=60 ! videoconvert ! nullsink")?;
pipeline.run().await?;

// Dynamic pipeline (programmatic)
let mut pipeline = Pipeline::new();
let src = pipeline.add_source("src", my_source);   // impl Source
let sink = pipeline.add_sink("sink", my_sink);     // impl Sink
pipeline.link(src, sink)?;
pipeline.run().await?;

// Typed pipeline (compile-time checked)
let source = from_iter(vec![1, 2, 3, 4, 5]);
let result = pipeline(source)
    .then(filter(|x: &i32| x % 2 == 0))
    .then(map(|x: i32| x * 10))
    .sink(collect::<i32>())
    .run()?
    .into_inner();
// result: [20, 40]

Re-exports

pub use error::Error;

pub use error::Result;

Modules

buffer

Buffer types for zero-copy data passing.

clock

Clock and time types for pipeline synchronization.

codec

Codec-adjacent utilities that depend on no codec library.

control

Runtime control: change a running pipeline without tearing it down.

converters

Format converters for video and audio data.

element

Element system for Parallax pipelines.

elements

Built-in pipeline elements.

error

Error types for Parallax.

event

Events and tagging system for pipelines.

format

Media format and capabilities types.

gpu

Hardware video decode.

memory

Memory management for Parallax.

metadata

Buffer metadata types.

negotiation

Caps negotiation for pipelines.

observability

Observability features: metrics and tracing.

pipeline

Pipeline construction and execution.

plugin

Plugin system for dynamically loading elements.

prelude

Prelude for convenient imports

subtitle

Timed text: cues, where they wait, and how to read them (#279).

temporal

Temporal types for time-sensitive stream processing.

typed

Typed pipeline API with compile-time type safety.

video

Presentation maths, with no graphics dependency.

wire

Wire types shared across transports.

Macros

define_plugin

Helper macro for defining plugin descriptors in Rust.