Skip to content
pre-alpha · open source · built in Rust

A Rust engine you can
actually open.

Eresh is an editor-first Rust game engine that you can actually open and run right in your browser, with no installation needed. It opens like Godot and runs like Rust: a forward+ PBR renderer on an archetype ECS, dual-licensed MIT/Apache. Pre-alpha, built in the open.

Try it in your browser → Get notified at launch
Language Rust 1.78+
Renderer wgpu · WGSL
Platforms Web · Win · macOS · Linux
License MIT / Apache-2.0
[01] · Why Eresh

Rust performance, without giving up the editor.

Everyone discovering Eresh asks the same thing in thirty seconds: why this and not another Rust engine? The honest answer is short.
▣

Built-in editor that saves scenes

Open the editor directly in your browser to author scenes visually, then save and reload them. There is no code-only workflow or complex setup needed to get started.

◈

Rust + ECS performance

A forward+ PBR renderer on an archetype ECS. Native Rust, designed as a data-oriented engine from the first commit rather than a binding or a port.

⎇

Open source

Dual-licensed MIT / Apache-2.0. No telemetry, no closed runtime, no per-seat fees. Built in the open from day one.

[02] · What works today

Honest about what’s built and what isn’t.

Eresh is pre-alpha. The systems below work today; others (audio, physics, scripting, build export) don’t exist yet. We’d rather show you the real state than a roadmap dressed up as a product.
F.01

Built-in editor Working

Open a scene, move objects, tweak lights and materials, then save and reload it. The editor compiles to WebAssembly and runs in your browser via WebGPU with no installation or account required.

▣
F.02

Forward+ renderer Working

A forward+ pipeline with PBR shaders, real-time shadows, spot / point / directional lights, a material system, and MSAA. Built in Rust on wgpu (Vulkan, Metal, DX12, WebGPU).

◐
F.03

Archetype ECS & Parallel Scheduler Core

A data-oriented entity component system with typed queries, resources, transform hierarchies, change detection, and a parallel scheduling model designed for cache-friendly iteration.

⌘
F.04

Asset pipeline Working

Import meshes (GLTF, FBX, OBJ, etc.) and textures through type-safe handles, a virtual filesystem, and hot reload. Change an asset to see it update immediately without restarting the editor.

⇄
F.05

Tooling Working

Built-in performance telemetry, GPU query pass profiling, memory footprint tracking, and panic/crash log dumping to track frame timings and resource usage.

◷
F.06

Honest about the gaps Roadmap

No audio, physics, gameplay scripting, or build export yet. Eresh is pre-alpha and clearly states what is missing. See exactly where things stand on the roadmap.

⋯
[03] · Roadmap

Shipped, in progress, and planned.

No dates and no hype; we choose direction over promises. Nothing here is committed until it’s already well underway.

Shipped

  • Editor: save/load, panel docking & chrome
  • Editor runs in the browser (WebGPU)
  • Translation gizmos & grid viewport helper
  • Content Browser drag-and-drop & drop zone overlays
  • GLTF, FBX, and OBJ mesh import support
  • Forward+ PBR renderer with real-time shadows
  • Parallel ECS scheduler & mutation tracking
  • Runtime type reflection & dynamic inspector
  • Play-in-Editor (PIE) simulation sandbox
  • Performance telemetry, GPU & memory tracking
  • Basic trace/spatial queries physics system

In progress

  • Render Graph (Frame DAG) & resource pooling
  • Shader database (preprocessing & compilation)
  • Clustered forward+ runtime & VSM shadow caching
  • Telemetry UI (editor HUD & CPU timeline charts)
  • Undo-redo transaction history & backup workflows
  • Static baked lighting (lightmaps & probes)

Planned

  • Retained UI (Taffy layout & cosmic-text shaping)
  • Full physics simulation (Rapier, rigid bodies, joints)
  • Gameplay scripting (Luau VM & Rust dylib hot reload)
  • Audio system (Kira, spatial emitters & DSP mixing)
  • Netcode (snapshot replication, client prediction, rollback)
  • Build / export tools for standalone games
  • Terrain system (GPU clipmaps & heightfields)
  • Agent-ready tooling: LLM-readable docs & a scriptable editor (a future direction, not a dated promise)

Curious how AI fits in? Read our AI policy →

[04] · Principles

Three ideas guiding development.

01 · Data over hierarchies

Game state belongs in tight, contiguous arrays rather than deep object trees. This isn’t a future optimization; it shapes every API decision from day one.

02 · Iteration is the feature

The gap between changing a value and seeing the result should be as short as possible. Hot reload and a live editor are first-class concerns, not afterthoughts.

03 · Open and honest

Dual-licensed MIT / Apache-2.0. No telemetry, no closed runtime, no per-seat fees. Pre-alpha and built in the open.

[05] · Stay in the loop

Get notified at launch.

We will send you a single email when Eresh goes public with the editor, the source, and the launch details. That’s it.