Strom - GStreamer Flow Engine

Strom ("Ström" - Swedish for "stream") is a visual, web-based interface for creating and managing GStreamer media pipelines. Design complex media flows without writing code.

Quick Demo: Open Source Cloud

Run this service in the cloud with a single click.

Visual pipeline editor showing a simple test flow

Features

• Visual Pipeline Editor - Node-based graph editor in your browser
• Real-time Control - Start, stop, and monitor pipelines via REST API or WebSocket
• Element Discovery - Browse and configure any installed GStreamer element
• Reusable Blocks - Create custom components from element groups (e.g., AES67 receiver)
• gst-launch Import/Export - Import existing gst-launch-1.0 commands or export flows to gst-launch syntax
• SAP/AES67 Discovery - Browse and monitor network audio streams via SAP announcements
• PTP Clock Monitoring - View PTP synchronization status and statistics per domain
• Media File Browser - Manage media files for playlist playback
• Links Page - Quick access to WHEP player pages and stream URLs
• System Monitoring - Real-time CPU, memory, and GPU usage graphs in the topbar
• Authentication - Secure with session login or API keys (optional)
• Auto-restart - Pipelines survive server restarts
• Native or Web - Run as desktop app or web service
• MCP Integration - Control pipelines with AI assistants (Claude, etc.)
• CI/CD - Automated testing, building, and releases for Linux, Windows, macOS, and ARM64
• Vision Mixer - Broadcast-style PVW/PGM video switcher with web control UI
• HTML Rendering - Render web pages as video sources using CEF (via strom-full Docker image)

Advanced Capabilities

• Dynamic Pad Linking - Automatic handling of runtime-created pads (decodebin, demuxers)
• Automatic Tee Insertion - Fan-out outputs without manual configuration
• Pad Properties - Configure per-pad properties (e.g., volume/mute on audiomixer inputs)
• Debug Graphs - Generate SVG visualizations of running pipelines
• WebSocket/SSE - Real-time state updates and pipeline events

Quick Start

Option 1: One-liner Install (Recommended)

curl -sSL https://raw.githubusercontent.com/Eyevinn/strom/main/install.sh | bash

The interactive installer detects your OS, downloads the latest release, and installs GStreamer dependencies.

For CI/CD or scripted installs, use environment variables:

curl -sSL https://raw.githubusercontent.com/Eyevinn/strom/main/install.sh | AUTO_INSTALL=true GSTREAMER_INSTALL_TYPE=minimal bash

Available options: AUTO_INSTALL, GSTREAMER_INSTALL_TYPE (full/minimal), SKIP_GSTREAMER, SKIP_GRAPHVIZ, INSTALL_DIR, VERSION.

After installation, run strom and open http://localhost:8080 in your browser.

Option 2: Using Pre-built Binaries

Download the latest release for your platform from GitHub Releases:

# Linux
wget https://github.com/Eyevinn/strom/releases/latest/download/strom-v*-linux-x86_64
chmod +x strom-v*-linux-x86_64
./strom-v*-linux-x86_64

# macOS
# Download and run the macOS binary

Windows: Download the MSI installer (strom-*-windows-x86_64.msi) for a one-click installation that bundles GStreamer and Graphviz. After installation, launch "Strom" from the Start Menu.

Alternatively, download the standalone .exe and install GStreamer manually.

Open your browser to http://localhost:8080 to access the web UI.

Option 3: Using Docker (Recommended for Testing)

# Pull and run the latest version
docker pull eyevinntechnology/strom:latest
docker run -p 8080:8080 -v $(pwd)/data:/data eyevinntechnology/strom:latest

# Or build locally
docker build -t strom .
docker run -p 8080:8080 -v $(pwd)/data:/data strom

Access the web UI at http://localhost:8080

Option 4: Building from Source

Prerequisites

# Install GStreamer (Ubuntu/Debian)
sudo apt install libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev \
  libgstreamer-plugins-bad1.0-dev gstreamer1.0-plugins-base \
  gstreamer1.0-plugins-good gstreamer1.0-plugins-bad \
  gstreamer1.0-plugins-ugly gstreamer1.0-libav \
  gstreamer1.0-tools libnice-dev gstreamer1.0-nice \
  libcairo2-dev graphviz

# Install GStreamer (macOS)
brew install gstreamer gst-plugins-base libnice-gstreamer

# Install Rust and tools
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup target add wasm32-unknown-unknown
cargo install trunk

Optional Features

# Build with EFP support (Linux)
sudo apt install cmake libclang-dev
cargo run --release --features efp

# Build with EFP support (macOS)
brew install cmake
cargo run --release --features efp

Pre-built Linux and macOS binaries, plus the Docker images, include the efp feature by default. Windows binaries currently ship without EFP because gst-plugin-efp has not been validated on that platform yet.

Run

# Production mode (web UI at http://localhost:8080)
cargo run --release

# Development with hot reload
cargo run                    # Backend on :8080 (Terminal 1)
cd frontend && trunk serve   # Frontend on :8095 (Terminal 2)

# Headless mode (API only)
cargo run --release -- --headless

First Steps

Once Strom is running:

1. Open http://localhost:8080 in your browser
2. Browse available GStreamer elements in the palette
3. Drag elements onto the canvas to create your pipeline
4. Connect elements by dragging from output pads to input pads
5. Configure element properties in the inspector panel
6. Click "Start" to launch your pipeline

For API usage, visit http://localhost:8080/swagger-ui for interactive documentation.

Docker Hub

Pre-built multi-architecture images (amd64/arm64):

docker pull eyevinntechnology/strom:latest
docker pull eyevinntechnology/strom:0.3.25  # Specific version

# Extended image with HTML rendering support (CEF/Chromium)
docker pull eyevinntechnology/strom-full:latest

The strom-full image includes gstcefsrc for rendering web pages as video sources. See docs/HTML_RENDER.md for details.

CI/CD automatically runs tests, builds binaries for Linux/Windows/macOS, and publishes Docker images on release.

Architecture

┌─────────────────────────────────┐
│  Frontend (egui → WebAssembly)  │
│  - Visual flow editor           │
│  - Element palette              │
│  - Property inspector           │
└────────────┬────────────────────┘
             │ REST + WebSocket/SSE
┌────────────▼────────────────────┐
│  Backend (Rust + Axum)          │
│  - Flow manager                 │
│  - GStreamer integration        │
│  - Block registry (AES67, ...)  │
│  - Storage (JSON or PostgreSQL) │
└─────────────────────────────────┘

Workspace Members: - strom-types - Shared domain models and API types - strom - Server with GStreamer pipeline management - strom-frontend - egui UI (compiles to WASM or native) - strom-mcp-server - Model Context Protocol server for AI integration

API Overview

Flows - GET/POST/DELETE /api/flows - Manage pipeline configurations - POST /api/flows/:id/start - Start pipeline - POST /api/flows/:id/stop - Stop pipeline

Elements - GET /api/elements - List available GStreamer elements - GET /api/elements/:name - Get element details and properties

Blocks - GET/POST/DELETE /api/blocks - Manage reusable component definitions - GET /api/blocks/categories - List block categories

Real-time - GET /api/events - Server-Sent Events stream - WS /api/ws - WebSocket connection

See OpenAPI docs at /swagger-ui when server is running.

gst-launch Import/Export

Import existing gst-launch-1.0 pipelines or export flows back to gst-launch syntax:

# Example: paste this into the import dialog
gst-launch-1.0 videotestsrc ! x264enc ! mp4mux name=mux ! filesink location=test.mp4

# API endpoints
POST /api/gst-launch/parse   # Parse gst-launch to flow
POST /api/gst-launch/export  # Export flow to gst-launch

Configuration

Configure via config files, CLI arguments, or environment variables (in priority order):

# Common options
--port 8080                    # or STROM_PORT=8080
--data-dir /path/to/data       # or STROM_DATA_DIR=...
--database-url postgresql://...  # or STROM_DATABASE_URL=... (for production)
RUST_LOG=info                  # Logging level

Storage: JSON files by default, PostgreSQL for production. See docs/POSTGRESQL.md.

Config file: Copy .strom.toml.example to .strom.toml for all options.

HTTPS/TLS

Strom supports HTTPS with automatic certificate hot-reload (zero-downtime renewal):

# CLI
strom --tls-cert cert.pem --tls-key key.pem

# Environment variables
STROM_TLS_CERT=cert.pem STROM_TLS_KEY=key.pem strom

# Or in .strom.toml
# [server]
# tls_cert = "cert.pem"
# tls_key = "key.pem"

Both certificate and key must be in PEM format. The certificate file can include intermediate certificates. For local development, generate certs with mkcert localhost <your-ip>.

Authentication

Strom supports optional authentication via session login (web UI) or API keys (programmatic access).

# Generate password hash
cargo run -- hash-password

# Configure and run
export STROM_ADMIN_USER="admin"
export STROM_ADMIN_PASSWORD_HASH='$2b$12$...'
export STROM_API_KEY="your-api-key"  # Optional: for API access
cargo run --release

See docs/AUTHENTICATION.md for full setup guide including Docker configuration.

Blocks System

Create reusable components from element groups:

Inputs: - Media Player - File and playlist playback with position tracking, loop support, and decode/passthrough modes - AES67 Input - Receives AES67/Ravenna audio via RTP multicast using SDP - WHEP Input - Receives audio/video via WebRTC WHEP protocol - WHIP Input - Hosts a WHIP server for browser/encoder ingest - MPEG-TS/SRT Input - Receives MPEG Transport Stream over SRT with decode or passthrough modes - EFP/SRT Input - Receives EFP (Elastic Frame Protocol) over SRT with decode or passthrough modes (Linux + macOS, requires efp feature) - DeckLink Video/Audio Input - Captures from Blackmagic DeckLink SDI/HDMI cards - NDI Input - Receives video/audio via NewTek NDI protocol - Inter Input - Subscribes to streams from other flows (inter-pipeline routing)

Outputs: - AES67 Output - Sends AES67/Ravenna audio via RTP multicast with SDP generation - WHIP Output - Sends audio via WebRTC WHIP protocol - WHEP Output - Serves audio/video streams via WebRTC WHEP with built-in player pages - MPEG-TS/SRT Output - Muxes audio/video to MPEG Transport Stream over SRT - EFP/SRT Output - Muxes audio/video to EFP over SRT (Linux + macOS, requires efp feature) - DeckLink Video/Audio Output - Outputs to Blackmagic DeckLink SDI/HDMI cards - NDI Output - Sends video/audio via NewTek NDI protocol - Inter Output - Publishes streams for other flows to consume - Recorder - Writes audio/video streams to file with configurable segmentation and auto-stop

Processing: - Audio Mixer - Digital mixing console with up to 32 input channels, per-channel processing (gain, gate, compressor, EQ, pan, fader, mute), auxiliary sends, groups, PFL bus, and main stereo bus with metering - Audio Router - Flexible multi-input channel routing matrix with mixing and fan-out capabilities - Video Encoder - H.264/H.265/AV1/VP9 with automatic hardware acceleration (NVENC, QSV, VA-API, AMF, software) - Video Format - Resolution, framerate, and pixel format conversion - Audio Format - Sample rate, channels, and PCM format conversion (supports surround sound) - Video Compositor - Multi-input compositing with GPU (OpenGL) and CPU backends - Vision Mixer - Broadcast-style PVW/PGM video switcher with CUT/AUTO transitions, DSK overlays, fade-to-black, multiview output, and web control UI

Analysis: - Audio Meter - RMS and peak level monitoring per channel - Audio Latency - Measures audio round-trip latency using GStreamer's audiolatency element - Loudness Meter - EBU R128 real-time integrated loudness, LRA, and true-peak measurement - Spectrum Analyzer - Real-time audio frequency spectrum visualization - Audio Analyzer - Real-time waveform and vectorscope visualization

Custom blocks can also be created via JSON or API.

See docs/BLOCKS_IMPLEMENTATION.md, docs/MIXER_BLOCK.md, docs/VIDEO_ENCODER_BLOCK.md, and docs/WHEP_OUTPUT_BLOCK.md for details.

MCP Integratio