rpgCore
The Valve Orange Box concept applied to solo indie dev — one engine, four completely different games, no duplicated systems
The Problem
I've been rebuilding the same systems since middle school. Every game needs an entity system, a state machine, a resource manager, save/load logic. The challenge was extracting these patterns into a reusable engine that could power completely different games without duplicating code.
My Approach
- → Valve Orange Box concept: one engine, multiple games
- → Python core engine for game logic and AI
- → Godot 4.x C# frontend for rendering and visual debugging
- → IPC communication between Python and C# layers
- → NEAT genetic algorithm for AI training
Key Highlights
- 3,628 commits between February and September 2026
- One engine, four completely different games
- No duplicated systems across games
- 20 years of unconscious pattern-finding finally made explicit
- Conceptual predecessor to OperatorGame (Rust rebuild)
How It Works
[!IMPORTANT] rpgCore was retired on 13 September 2026. Its work continues in RFDGameStudio, where a snapshot is archived for reference and recovery, and its patterns carried into the Rust-based OperatorGame. The retrospective covers what was kept.
The Concept
The Valve Orange Box: Half-Life 2, Episode One, Episode Two, Portal, Team Fortress 2. Five completely different games. One engine.
I wanted to apply that concept to solo indie dev: one engine, four completely different games, no duplicated systems.
The Origin Story
I’ve been rebuilding the same systems since middle school.
Every game needs:
- An entity system
- A state machine
- A resource manager
- Save/load logic
- Audio handling
- Input management
I wrote these systems over and over. Sometimes in C++, sometimes in Python, sometimes in JavaScript. Same patterns, different syntax.
rpgCore is the moment I stopped rebuilding and started extracting.
The Engine
rpgCore is a multi-genre game engine capable of powering:
- Space shooters
- RPGs
- Tycoon games
- Strategy games
With integrated AI learning systems via NEAT.
The Architecture
Three-Layer Design:
Layer 1: Python Core Engine
- All game state, physics, AI logic
- ECS framework for decoupled game logic
- NEAT genetic algorithm for AI training
- Pydantic for configuration
Layer 2: Godot Frontend (C#)
- Rendering and visual debugging
- Socket IPC communication with Python core
- Real-time visualization of game state
Layer 3: NEAT Integration
- Neural networks evolve through genetic algorithm
- Learning to play games through environmental feedback
- Visualization of neural network evolution
The Commit Count
3,628 commits.
All of them between February and September 2026: iterative refinement, finding patterns, extracting them, refining them again.
The Insight
This project taught me that architectural clarity often matters more than raw performance for game prototyping. The benefits of clear separation of concerns outweighed the overhead of socket communication.
Keeping the test suite green gave me the confidence to refactor aggressively, a principle that carried over to its successor, OperatorGame.
The Legacy
rpgCore represents 20 years of unconscious pattern-finding finally made explicit. The systems I rebuilt since middle school — now extracted, tested, and reusable.
The successor, OperatorGame, takes these patterns to Rust for production-grade performance and cross-platform mobile stability. But the architectural insights came from rpgCore.
GitHub: rpgCore Successor: RFDGameStudio · patterns also carried into OperatorGame
Built with Python, Godot 4.x, and C#. 3,628 commits. One engine, four games.