Build Worlds.
Tell Stories.
A hand-crafted RPG engine built from scratch — tile maps, living NPCs, branching dialogue, faction politics, and a fully custom content editor, all woven together.
What's Inside
A Complete RPG Foundation
Every layer of a role-playing game — from raw pixels to branching quest lines — designed to work together cohesively rather than bolted on as afterthoughts.
Layered Tile Maps
Multi-layer room system with per-layer NPC placement, tile painting, and live canvas preview. Maps resize non-destructively and remember every edit through a branching history system.
World BuildingInstance-Based NPCs
NPCs are first-class world objects — each instance carries its own identity, position, layer, sprite, faction, and dialogue assignment. Templates seed instances; instances live their own lives.
CharactersBranching Dialogue
A full dialogue runtime with nodes, choices, and flags. Conversations can gate on world state, advance quests, and leave lasting marks on the game world — all authored without touching code.
NarrativeAbilities & Combat
Data-driven ability definitions let designers craft spells, attacks, and skills without engine changes. The runtime resolves them against the entity-component system in real time.
GameplayFaction System
Characters and NPCs belong to factions that shape their behavior and relationships. Faction affiliation flows from templates to instances and influences how the world reacts to the player.
PoliticsQuest Engine
Quests are authored as structured data — objectives, rewards, and state transitions all live in content files. The runtime tracks progress and drives world reactions without hard-coded story logic.
StoryItems & Loot Tables
A rich item schema with weighted loot tables that populate treasure dynamically. Every drop can be tuned by designers without touching a single line of engine code.
EconomyLive Content Editor
A React-powered web editor runs alongside the engine. Edit maps, NPCs, dialogues, items, and quests in a live UI — changes hit the disk instantly and the runtime picks them up seamlessly.
ToolingNative C++ Runtime
The game runtime is a hand-written C++ engine using SDL2 — no third-party game framework, no black boxes. Every system, from the tile renderer to the ECS, is owned and understood.
PerformanceWorld Design
Every tile tells a story
Maps are built from character-based tile layers that compile directly into the game runtime. The same tile data that renders in the editor is what the C++ engine reads — no export steps, no format conversions. What you see is exactly what the player walks through.
Layers stack transparently: base terrain on the ground floor, decorations above, NPCs floating on whichever layer makes narrative sense. The "All Layers" view shows the complete picture; individual layers can be isolated for precise editing.
History & Undo
Nothing is ever lost
The map editor maintains a full branching history of every change — tile strokes, NPC moves, layer additions, map resizes. Undo and redo navigate the tree freely.
History is persisted across sessions. Reopen the editor and your full undo tree is exactly where you left it, right down to the currently selected step.
Design Philosophy
Built to be understood
Data-Driven Everything
Game content lives in structured JSON — not in code, not in binary blobs. Every system reads from files the editor writes, making iteration instant and fearless.
No Abstraction Tax
The engine is written to be read. No framework magic, no engine-within-an-engine. Every line of C++ does exactly what it says and nothing it doesn't.
Editor as First-Class Citizen
The content editor is not an afterthought. It was designed alongside the runtime so that what the tool produces is exactly what the game consumes — always.
Technology
Chosen with care
Every technology in the stack was chosen because it earns its place — no excess dependencies, no frameworks used as crutches.
