Pulsar Engine — 01 / Home

Build without

An open-source game engine written entirely in Rust. Custom GPU-driven renderer, ECS core, visual blueprint scripting, and a crash-isolated editor — built to compete at the highest level.

Get Started GitHub Download

Rust · 100%GPU-drivenMIT license

Fig. 01 — Engine

Level Editor01/07

live preview

Far-Beyond-Pulsar / Pulsar-Nativewgpu · Renderer

02 / 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.

Cargo workspace

Helio — GPU-driven renderer

Helio is Pulsar's custom wgpu renderer built from scratch. A GPU-driven pipeline with compute-shader frustum culling means the CPU hot path is O(1) regardless of scene size. Zero-copy texture sharing keeps pixel data in VRAM through the full compositor stack.

wgpu · Vulkan · DX12 · Metal

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.

Background-threaded · 60 TPS

03 / 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

Pulsar Editor — default.scene

live scene60 TPS physics

Deployment targets

desktop · web · xr — one codebase

Windows/

macOS/

Linux/

Android/

Vulkan/

DirectX 12/

Metal/

OpenGL/

OpenGL ES/

WebGL2/

wgpu/

WebAssembly/

WebGPU/

OpenXR/

Blueprint Editor — player_controller.bp

node graph#[blueprint]

04 / 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 docs

05 / 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.

main.rs

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();
}