Skip to main content
DevPixelForge (dpf) gives your Go applications the power to resize, transcode, watermark, normalize, and transform images, video, and audio — all through a simple JSON protocol backed by a Rust engine that runs at native speed.
“Transform pixels at the speed of Rust.”

Quick Start

Get your first image resized in under 5 minutes

Go Integration

Embed dpf into any Go project with the client library

Image Operations

14 image operations: resize, crop, watermark, optimize and more

Video & Audio

Transcode, trim, normalize, and extract thumbnails

What is DevPixelForge?

DevPixelForge is a multimedia processing engine split into two components:
  • dpf — A compiled Rust binary that accepts JSON jobs via stdin and returns results via stdout. It handles all heavy lifting: image decoding, pixel manipulation, FFmpeg-based video/audio processing, and parallel batch execution.
  • Go bridge — A thin Go client package (dpf) that spawns and communicates with the Rust binary. It exposes typed job structs and two client modes for different performance needs.

Supported operations

CategoryOperations
ImagesResize, crop, rotate, watermark, adjust, optimize, convert, palette, favicon, sprite, placeholder, srcset, EXIF
VideoTranscode, resize, trim, thumbnail, web profiles, metadata
AudioTranscode, trim, normalize (LUFS), silence removal

Key features

  • High performance — Rust-powered with parallel processing via Rayon; LTO-optimized release binary
  • Multiple formats — PNG, JPEG, WebP, AVIF, GIF, ICO, SVG, MP4, WebM, MP3, AAC, Opus, FLAC
  • Two client modes — One-shot (simple, stateless) and Streaming (persistent process, low latency)
  • Static binary — musl-compiled for zero-dependency deployment across Linux distributions
  • Smart image operations — Focal point cropping, entropy-based selection, auto-quality binary search
  • Inline output — Base64-encoded results for serverless and streaming use cases

How it works

┌─────────────────┐      JSON/stdio      ┌──────────────────┐
│   Go Bridge     │◄────────────────────►│   dpf (Rust)     │
│  (Client)       │   stdin/stdout       │  (Engine)        │
└─────────────────┘                      └──────────────────┘
  1. Your Go code creates a job struct (e.g., ResizeJob) and calls the client
  2. The Go client serializes it to JSON and sends it to the Rust binary via stdin
  3. The Rust engine processes the job and writes a JobResult JSON to stdout
  4. The Go client deserializes the response and returns it to your code

Usage modes

One-shot, streaming, stdin, and batch modes explained

Streaming client

Reuse the Rust process for high-throughput workloads

Batch processing

Run multiple jobs in parallel with a single call

Building from source

Build instructions for Rust, Go, and static binaries

Build docs developers (and LLMs) love