Hi Community 
Today I’d like to introduce a project I’ve been building with a very specific philosophy in mind:
What if we brought NES-style structured development to modern ESP32 hardware?
That’s how PixelRoot32 was born.
PixelRoot32 is a retro-inspired game engine designed specifically for the ESP32 microcontroller family. The goal is not just to render graphics — but to recreate the constraint-driven, architecture-first mindset of classic console development.
The Core Idea
Back in the NES era, developers worked with:
-
Strict memory limits
-
Deterministic execution
-
Hardware-aware rendering
-
Fixed update loops
Those limitations didn’t block creativity — they shaped it.
PixelRoot32 follows that same philosophy.
Instead of abstracting everything away, the engine embraces structure, predictability, and tight control over hardware resources.
What PixelRoot32 Focuses On
This is not just a rendering framework. It is a low-level engine architecture built around:
-
Deterministic game loops
-
Tile-based rendering pipeline
-
Tight memory control
-
Hardware-aware performance design
-
Clean separation between engine core and game logic
-
Modular architecture for embedded scalability
The objective is to provide a focused development environment where limitations drive creativity.
Engine Architecture Philosophy
PixelRoot32 is built around a structured update pipeline:
-
Fixed-step game loop
-
Logic update (no physics integration inside entities)
-
Dedicated collision system
-
Deterministic resolution
-
Rendering stage
This ensures:
-
Stable simulation
-
Reproducible behavior
-
Embedded-friendly performance
Everything is designed to run predictably on constrained hardware.
Current Development Focus: Physics System
Right now, development is centered around a deterministic Physics System specifically designed for embedded environments.
The physics architecture includes:
-
Flat solver pipeline
-
Deterministic collision resolution
-
Stable fixed-step integration
-
Explicit penetration correction
-
Designed to eliminate jitter and instability
Actor Hierarchy
The engine implements a clear actor model:
-
StaticActor -
KinematicActor -
RigidActor
Each one has clearly defined responsibilities inside the collision pipeline to maintain predictability.
Physics documentation (WIP):
https://github.com/PixelRoot32-Game-Engine/PixelRoot32-Game-Engine/blob/feat/physics-system/docs/PHYSICS_SYSTEM_REFERENCE.md
Note: The actor model is inspired by the physical body differentiation used in Godot, adapted to a deterministic approach and optimized for embedded environments such as the ESP32.
Why ESP32?
The ESP32 is powerful enough to handle structured 2D engines while still forcing smart architectural decisions:
-
Limited RAM encourages memory discipline
-
No GPU forces efficient rendering design
-
Real hardware timing makes determinism meaningful
-
A perfect balance between constraint and capability
Long-Term Vision
PixelRoot32 is not meant to stop at software.
The long-term vision is to build a dedicated retro-style dev kit board powered by ESP32, where developers can:
-
Build their own mini consoles
-
Develop structured 2D games
-
Work close to the hardware
-
Learn low-level game architecture
The idea is to create a small hardware + software ecosystem focused on embedded game development.
Project Links
Official site:
https://pixelroot32.org/
GitHub repository:
https://github.com/PixelRoot32-Game-Engine/PixelRoot32-Game-Engine
Community Feedback
I’d genuinely love to hear your thoughts:
-
Would you be interested in an ESP32-based retro dev kit?
-
Any suggestions for hardware features?
-
Display recommendations?
-
Memory expansion ideas?
Thanks for reading — and I’m excited to connect with the community! 
If there’s interest, I can share deeper architectural breakdowns in future updates.