Heads up — Pulsar isn't ready to make games just yet. A beta is expected in Q1–Q2 2027.
Build without
An open-source game engine written entirely in Rust. Virtual-geometry renderer, ECS core, visual blueprint scripting, voxel terrain, and a crash-isolated editor — aiming to compete at the highest level.
02 / Latest Posts
From the Pulsar blog.
View all posts03 / Core Technology
A stack chosen
deliberately.
Every component exists because it makes the engine better — not because it was trendy.
Rust all the way down
The editor, renderer, physics, and plugins are all standard Rust. Your project is a Cargo workspace with an ECS core — no managed runtime, no garbage collector. An optional bytecode VM for visual scripts calls into Rust-backed dynamic libraries, giving you rapid iteration without sacrificing native performance.
Helio — GPU-driven renderer
Helio is Pulsar's custom wgpu renderer built from scratch. A GPU-driven pipeline with compute-shader culling and virtual geometry keeps CPU cost nearly flat as scene size grows — hundreds of millions of source triangles stream through at interactive rates. Zero-copy texture sharing keeps pixel data in VRAM through the full compositor stack.
Rapier3D physics
Pure-Rust physics running on a dedicated background thread at a fixed 60 TPS — fully decoupled from the render loop. Rigid bodies, collision detection, joints, and constraints, all deterministic and WASM-compatible.
04 / The Editor
A professional environment,
without the lock-in.
Pulsar's editor is built on GPUI — the same GPU-accelerated UI framework that powers the Zed editor. It runs in its own thread, meaning a game crash never takes down your workspace. Everything you see can be replaced or extended with a compiled Rust plugin.
- Visual blueprint scripting backed by a Rust-native bytecode VM
- Multi-panel layout — dockable viewport, asset browser, terminal, profiler
- Integrated Rust Analyzer LSP for in-editor code intelligence
- Live scene editing with real-time physics preview at fixed 60 TPS
- Plugin system — extend the editor with hot-reloadable Rust DLLs
- Built-in database editor and project-level asset management
05 / Pulsar Hub
Your projects,
one launcher.
The Hub is the front door to Pulsar: it keeps your projects and engine versions in one place, and opens them in the editor. It's what the download page installs today.
- Home feed pulling the latest posts from the Pulsar blog
- Project cards with thumbnails and last-opened times, plus search
- Per-project actions: open, Git manager, project settings, move, reveal in file explorer
- Engine Versions: the engine builds your projects run on
- Templates to start from, and a Dependencies page
- Open any existing folder as a project
Windows/
Linux/
Vulkan/
DirectX 12/
Metal/
WebGL2/wgpu/
WebAssembly/
WebGPU/
OpenXR/
06 / Visual Scripting
Blueprints that compile
to native Rust.
Visual blueprint graphs are a first-class frontend for Rust code. Annotate any function with #[blueprint] and it appears as a node in the graph editor. Pure functions, exec-flow nodes, events, and control flow are all supported out of the box.
At runtime, blueprints execute through a lightweight bytecode VM that calls directly into Rust-backed dynamic libraries — giving designers fast iteration without touching source, and engineers full native performance where it counts.
Read the Blueprint docs07 / Helio Renderer
Not enough triangles?
Not a problem.
Helio's virtual geometry selects detail per cluster on the GPU, so scanned, film-grade assets render at full fidelity without hand-built LODs. Every shot below is captured live from Helio's VG Museum demo.
Read: Not Enough Triangles
08 / Voxel Worlds
Dig anything,
anywhere.
Destructible voxel terrain is a first-party plugin. Worlds are built from exact voxels, generated on the GPU and drawn from chunk trees — the goal is that you never see detail arrive or levels switch, from the ground to orbit.
- Planets
- Earth-sized cube-sphere planets, finite planes, or effectively infinite planes.
- Chunk trees
- 64³-cell chunks generated on the GPU and streamed as a cut of an octree per cube face.
- Destructible
- Brushes from a single voxel up to the whole planet. An edit shows on the next frame.
- Terrain layers
- Ordered layer stacks with presets (Earth, moon, desert, flat), craters, erosion, rivers, lakes and climate maps.
- Caves & cliffs
- Generated cave networks, tunnels, chambers, ledges and overhangs.
- Features
- Procedural trees, rocks and buildings, generated wherever a cell is asked for.
- One world, two consumers
- CPU (collision, ray casts, edits) and GPU (generation, drawing) evaluate the same integer field, bit for bit.
09 / Atmosphere, Water & Light
Worlds that feel
like places.
Each of these is its own plugin with its own renderer feature — switch it off in your project and the frame simply draws without it.
Sky & weather
A planet's air: atmosphere, the sun's colour through it, sun disc, aerial perspective and clouds. Presets give you Earth-like skies, and voxel worlds can tell the sky about the ground they sit on.
Ocean & water
A camera-centred FFT ocean with Fresnel/GGX sun reflection and glints, refraction, Beer–Lambert extinction, foam, caustics and underwater light shafts. Shore waves are driven by a terrain-derived coastline map.
Read: Water Is a Volume
Lighting that holds together
Local and directional lights with shadows and IES profiles, froxel-based volumetric fog, and world-space diffuse global illumination from a camera-centred probe clipmap.
10 / Architecture
Every object kind
is a plugin.
A plugin owns its components, the contracts other plugins read, the Helio renderer feature that draws it, its file formats and its editor UI. The renderer itself knows no object kind.
Projects enable or disable plugins in Pulsar.toml. Disabled, a kind is simply absent and the frame draws without it. First-party plugins are MIT-licensed and live in their own repositories.
25+ first-party plugins
SceneDB
The scene is a database of component rows. Assets are held in a budgeted rebuild-on-miss cache, with a derived-data cache on disk and cooked textures (a 4K JPEG becomes 5.3 MiB of BC7 with a full mip chain).
Read the deep diveParent-relative worlds
Transforms resolve on the GPU with dirty-subtree propagation and camera-relative precision. Level instances drop into a scene, and portals take their lighting and materials from the world they show.
Read the deep divePhysical lens
The camera reconstructs real optical behaviour from lens prescriptions, spectral ray mapping and pupil functions, in GPU compute.
Read the deep diveBeta expected Q1–Q2 2027
Like what you see? Follow along as it comes together.
11 / Developer Experience
Rust you already know.
No custom scripting language to learn. Your game code is plain Rust, with proc-macros bridging it into the editor's visual systems.
Initialize the engine, register types, and run your game.
use pulsar_std::prelude::*;
pub fn main() {
env_logger::init();
let mut app = PulsarApp::new();
// Register your project types
app.register_type::<GameState>();
app.register_type::<Inventory>();
app.register_type::<PlayerData>();
// Attach game systems
app.add_system(game_state_system);
app.add_system(inventory_system);
app.add_system(player_update_system);
// Load scene and run
app.load_scene("scenes/default.level");
app.run();
}12 / Community
Built in the open,
by the community.
Far-Beyond-PulsarJoin the Discussion
Have ideas or questions? Connect with contributors and share your projects on GitHub Discussions.
Contributing to Pulsar
We welcome contributions of all sizes — from documentation fixes to new rendering features.
Engine Architecture RFC
Read the open RFC on the multi-layer compositor design and how the editor pipeline works.
Help shape
Pulsar's core systems are still being designed. The best time to influence its direction — and learn along the way — is right now.