softbuffer

softbuffer is a Rust crate for showing a CPU-rendered image inside a window in a cross-platform way. Where most realtime rendering libraries target the GPU (wgpu, ash, and similar), softbuffer fills the gap for cases where CPU rendering makes sense: learning, simple 2D scenes and GUIs, or a fallback path when no GPU is available.

It integrates with any windowing crate that implements raw-window-handle - such as winit or sdl3 - by creating a Context and Surface from the window, handing you a mutable pixel Buffer to draw into, and presenting it to the platform compositor. It deliberately provides only the raw buffer, leaving drawing primitives to higher-level crates.

What You Get

• A Context and Surface API built on top of any raw-window-handle window (winit, sdl3, etc.)
• Direct access to a mutable Buffer of pixels you draw into on the CPU
• Cross-platform backends covering Windows, macOS, X11, Wayland, ORBital, web, and more
• A present() / partial-present path that hands the buffer to the OS compositor efficiently
• Example programs for animation, ray tracing, and integration with winit

Common Use Cases

• Building a simple 2D application or GUI without pulling in a GPU stack
• Providing a software-rendering fallback when a GPU or drivers are unavailable
• Teaching or experimenting with rasterization and rendering from scratch
• Displaying CPU-generated images such as ray tracer or plotter output in a window

Under The Hood

Architecture - The public API in src/lib.rs is a thin generic layer: Context<D> and Surface<D, W> are parameterized over display and window handle types and delegate to a platform backend through a dispatch enum (backend_dispatch.rs) that implements a common backend_interface.rs trait. Concrete implementations live under src/backends/ (Win32, macOS/CoreGraphics, X11, Wayland, KMS/DRM, web, ORBital, etc.). Buffer exposes the CPU-writable pixel slice, present/present_with_damage hand it to the compositor, and format.rs/pixel.rs define the pixel layout.

Tech Stack - Rust built around the raw-window-handle abstraction for windowing interop, with per-platform system crates (e.g. windows-sys, core-graphics, x11rb/wayland client libraries) pulled in conditionally per backend. Includes benches and a large examples suite.

Code Quality - The crate is actively maintained under the rust-windowing org with a health score of 73, a detailed CHANGELOG, clippy configuration, and many runnable examples that double as integration checks across backends. The backend-trait design keeps platform code isolated and consistent.

API Design - The workflow is small and predictable: create a Context, build a Surface, resize it, grab a Buffer, write u32 pixels, and present(). By intentionally not shipping drawing primitives, the API stays focused and composes cleanly with higher-level 2D crates, while the generic handle parameters let it slot into any windowing library.