SHROOM ENGINE

Early Development — In Progress

Fast iteration.
Clean architecture.
Built for real-time engines.

A modern C++ engine focused on ECS, Vulkan, and developer-first workflows.

Explore ArchitectureFollow Development
ECS
Physics
Script
Render
Click a node to inspect its system

Core Features

Built for performance and developer experience

Vulkan RAII Core

Modern C++20 RAII wrapper around Vulkan for safe, efficient graphics programming.

True ECS (EnTT)

Powered by EnTT for cache-friendly, high-performance entity-component systems.

Hybrid 2D / 3D

Unified pipeline supporting both 2D sprites and 3D meshes in the same scene.

ShroomScript

Custom scripting language designed specifically for ECS workflows and hot reload.

Hot Reload System

Iterate instantly with automatic asset and script reloading at runtime.

Editor & Tooling

Professional editor in development, designed for speed and developer clarity.

Built Like a Real Engine

Clean separation of concerns and modern architecture patterns

Renderer
Render Graph
Render API
Vulkan
GPU Backend
Abstraction Layer
systems/movement.cpp
void MovementSystem::update(float32 dt) {
  // ECS iteration over entities
  auto view = registry.view<Transform, Velocity>();

  for (auto  entity : view) {
    auto& [transform, velocity] = view.get(entity);

    transform.position += velocity.value * dt;
  }
}

ShroomScript — Built for ECS

A custom scripting language designed specifically for game engine workflows

Why ShroomScript?

Traditional scripting languages weren't designed for modern ECS architectures. ShroomScript provides first-class support for component queries, systems, and the data-oriented patterns that make game engines fast.

Statically Typed
Hot Reload
ECS Native
Zero-cost abstractions
Compiled to optimized bytecode
Integrated debugging
Breakpoints and runtime inspection
C++ interop
Seamless integration with engine code
playerController.shs
system PlayerController {
// Query components
query(Transform, PlayerInput)
fn update(float dt) {
let speed = 5.0
// Hot-reloadable logic
if (input.is_pressed(Key::W)) {
transform.y += speed * dt
}
if (input.is_pressed(Key::S)) {
transform.y -= speed * dt
}
}
}

Professional Editor

Designed for speed and clarity

Scene: MainScene
Editor in development — designed for speed and clarity

PBR Rendering

Physically-based materials with realistic lighting

Real-time IBL
Image-based lighting with HDR
Cook-Torrance
Industry-standard BRDF
Shadow Maps
Cascaded directional shadows

Performance First

Optimized for real-time performance from the ground up

*All performance metrics shown are target goals and are subject to change as the engine evolves. They do not reflect current production performance.

10,000+
Sprites @ 60 FPS
Batch rendering with automatic instancing
< 10
Draw Calls
Aggressive batching and render graph optimization
< 2ms
Script Update
Fast bytecode VM with JIT compilation

Rendering Pipeline

Command Buffer Generation0.3ms
Shadow Pass0.8ms
Main Render Pass1.2ms

System Performance

ECS Update (10k entities)0.5ms
Physics Simulation1.1ms
Audio Processing0.2ms

Development Roadmap

Long-term vision for the engine.

Phase 1

Core & Renderer

In Progress
Basic Window
Event & Input System
Console & logging
Vulkan RAII wrapper
ECS integration (EnTT)
Phase 2

Editor

Upcoming
Basic 2D/3D rendering
Scene hierarchy
Inspector panels
Transform gizmos
Asset pipeline
Asset browser
Phase 3

Advanced Systems

Planned
Physics integration
Animation system
Particle effects
Audio engine
Networking foundation
Phase 4

Production Ready

Planned
Build pipeline
Profiling tools
Documentation
Example projects
Platform support
Phase 5

Expansion

Future
Mobile support
Web target (WASM)
Advanced rendering
Multiplayer systems
Plugin system

Follow the development of Shroom Engine

This is an early-stage project built in public. Watch it evolve from foundation to a production-ready engine.

Built in public — early stage project