There are many excellent ways to build a game today.
Unity and Godot provide powerful tools, mature editors, large communities, asset pipelines, physics systems, and standard features that would take years to recreate from scratch. For many projects, using an established engine is unequivocally the right decision.
So why build a custom engine as an indie developer?
The short answer comes down to control, long-term velocity, and workflow efficiency for a small team. As an extremely small team, every hour spent wrestling with general-purpose engine bloat or fighting against a framework's core assumptions is time taken away from what actually makes our game special.
Our upcoming title, Nine Lives, demands a very specific set of requirements: a particular combat rhythm, a custom event-driven item system, a Lua scripting layer, a Tiled-based map pipeline, specialized collision behavior, custom rendering layers, and a distinct visual identity. Building a tailored engine allows those systems to be designed around our exact needs.
However, the goal with the Tiler engine extends beyond a single project.
While optimized for our immediate needs, Tiler is architected as a modular, general-purpose 2D engine. It is built to serve as a high-speed, high-performance foundation for future games across entirely different genres.
Clean Separation of Concerns & Parallel Workflow
To make this viable for a micro-team, Tiler relies on a strict, clean separation of concerns between low-level engine code and high-level game content:
- Engine Code (C++): Handles core performance-critical systems: rendering, collision detection, asset management, and hardware abstraction.
- Game Content & Behavior (Lua & Data): Defines specific gameplay rules, item stats, entity attributes, quest logic, and dialogue without needing to touch or recompile C++ code.
This architecture enables seamless, parallel iteration. Engine development and game design don't block each other. While low-level engine architecture is being refactored or optimized, designer-facing content, level designs in Tiled, sprite animations, and gameplay scripts can continue to be written, tweaked, and hot-reloaded in real-time.
Scalability for Future Projects
By separating core foundational blocks,like our custom entity editor, Tiled integration, asset management, and base collision logic from game-specific behavior, we can rapidly iterate on new concepts.
For example, transitioning from a top-down action RPG to a Metroidvania doesn't mean starting over. It simply means swapping out or reconfiguring specific modules, such as replacing top-down movement with platforming physics and gravity, while retaining the robust tools, pipeline, and editor infrastructure we’ve already battle-tested.
This approach fundamentally changes the trade-off dynamic:
In an established engine, many low-level problems are already solved, but you are bound to the engine's overarching abstractions and workflow overhead.
With a focused custom engine, there is zero generic boilerplate between the idea and the result. When movement feels off, we inspect our own movement code. When collision behaves unexpectedly, we debug our exact implementation. When we need a custom rendering pass, we adjust our own render pipeline.
There is, of course, a cost. Writing resource management, scene management, debugging tools, and hardware abstraction takes time away from immediate gameplay development. If not scoped carefully, an engine can easily swallow the game itself.
That is why Tiler’s design philosophy balances specificity with reusability. It isn't trying to be an all-in-one suite to rival commercial behemoths; it is a lightweight, adaptable 2D engine framework designed to make a tiny team work significantly faster with every game we build.
For many projects, off-the-shelf engines remain the ideal path. But for us, building a modular, custom engine provides both the low-level precision required for Nine Lives and a flexible foundation to build our next 2D titles in a fraction of the time.