The landscape of game development has undergone a seismic shift as studios move away from the “black box” nature of commercial engines toward more transparent, foundational frameworks. Anand Naidu, a veteran in both frontend and backend architecture, has spent years dissecting the intricacies of how code translates into player experience. With the recent open-source release of the BRUTAL framework, Naidu offers a unique perspective on why the industry is pivoting toward custom-built proprietary engines. This conversation explores the technical and philosophical reasons why studios are reclaiming their tools, the role of artificial intelligence in navigating complex C# libraries, and the reality of building a game from the ground up without the safety net of traditional third-party support.
Major shifts in engine licensing and the removal of core features have recently caused a lot of anxiety among developers. How do these technical instabilities influence the decision to move toward a framework like BRUTAL?
The industry is still feeling the stinging aftereffects of the Unity Runtime Fee saga, which sent shockwaves through the community and broke the fundamental trust between engine providers and creators. When you see a giant like Epic Games announcing the depreciation of Unreal’s Blueprints function, it forces you to realize that your entire project is built on shifting sands. These “debarcles” aren’t just administrative headaches; they are existential threats to a studio’s stability and financial health. By adopting an open-source framework like BRUTAL, developers are essentially building a fortress around their intellectual property. It offers a way to avoid the fear of having a license terminated over false accusations of policy violations, ensuring that a team’s tools are as independent as their creative vision.
How does the technical architecture of BRUTAL, specifically its combination of C# and low-level C++ libraries, differentiate it from the user-friendly interfaces of engines like Godot?
BRUTAL is not a “drag-and-drop” solution; it is a sophisticated programming framework that demands a deep understanding of the nuts and bolts of C#. It intentionally avoids the polished editors seen in other engines, instead providing a foundation of .NET and C++ libraries with direct, low-level graphics access. This means you aren’t just clicking buttons to place objects; you are architecting the very ways those objects interact with the hardware. For developers, this provides an incredible level of precision, but it also means there is a much steeper learning curve than what you would find in an engine like Godot. It is designed for those who want to build their own proprietary tools from scratch, offering a “brutally” structured environment that prioritizes control over convenience.
We have seen high-profile successes like Ludeon Studios porting Rimworld to their own engine. What are the tangible performance benefits for players when a developer moves away from a monolithic engine?
The port of Rimworld from Unity to the new Waylith engine is a perfect case study for the efficiency gains of custom frameworks. Players immediately noticed significantly faster start-up times and overall smoother performance because the engine was tailored specifically for that game’s unique needs. When you use a general-purpose engine, your game is often dragging along thousands of lines of code and features it doesn’t actually use, which acts like digital dead weight. By building on a framework like BRUTAL, a studio can strip away the bloat and optimize the low-level graphics access for their specific simulation or rendering requirements. It transforms the game from a guest in someone else’s house into a resident of a structure built exactly to its own specifications.
There has been a lot of discussion regarding the role of AI in coding. How are modern developers using large language models to overcome the complexity of working with highly structured frameworks?
The complexity of navigating Vulkan documentation or deep C# libraries can be daunting, but advancements in large language models have turned these “brutally structured” languages into an advantage. Instead of “vibe-coding”—where an AI just guesses what you want—developers are using LLMs to tokenize language and build linkages between complex vectors of technical data. This allow teams to ask precise questions about syntax and library interactions, receiving structured answers that help them navigate the framework’s architecture. It’s about using AI as a highly specialized technical librarian rather than a replacement for a programmer. When the language is this structured, the AI can be incredibly accurate, making the daunting task of building an engine from scratch feel much more manageable for a small team.
The philosophy that “you are only as independent as your tools are” seems to be a driving force for this movement. Does this imply that the era of the “universal” game engine is coming to an end for serious independent studios?
We are seeing a clear divergence where developers like Mega Crit are switching to Godot for projects like Slay the Spire, while others are going even further by creating their own frameworks. The threat of having your license revoked or your business model upended by a third party has made the “option” to build your own engine a necessity rather than a luxury. While not every small studio has the resources to embrace the nuts and bolts of a framework like BRUTAL, those who do gain a level of sovereignty that is impossible with commercial engines. It prevents a situation where a platform operator can hold your project hostage over terms of service changes. This movement isn’t about creating a new industry standard, but rather about encouraging a “simpler,” more fragmented ecosystem where every studio owns the means of their production.
What is your forecast for the adoption of open-source frameworks in the next few years?
I expect we will see a surge in “bespoke” development where studios use frameworks like BRUTAL to create highly specialized, proprietary engines that do one thing exceptionally well. As AI tools continue to lower the barrier for understanding low-level documentation, the “daunting task” of manual engine building will become a viable path for mid-sized teams who are tired of the royalty requirements and stability issues of the big players. We won’t see a single framework replace Unity or Unreal, but rather a thousand smaller, more efficient engines blooming across the industry. This will lead to a more diverse technical landscape where performance and developer independence are prioritized over the convenience of a one-size-fits-all editor. Ultimately, the future belongs to those who are willing to sit down and ask the hard questions about how their technology actually works.
