A decision made before the brief
When a studio begins pre-production, the engine is already constrained by what its developers have mastered, what the platform holder will certify, and whether the runtime can be licensed at all. The choice is not a feature comparison made in a week; it arrives trailing years of institutional knowledge, and changing it mid-project is expensive enough to be almost unknown in commercial development.
The two broad options — a commercial engine licensed from a third party, or a proprietary system built and maintained in-house — have different cost structures and different ceilings. A commercial engine such as Unreal Engine, licensed from Epic Games, charges no upfront royalty on console titles below a revenue threshold but takes a percentage beyond it, a figure Epic revised publicly in 2023. Unity's pricing has shifted more than once, and its 2023 Runtime Fee proposal created documented turbulence across small and mid-size studios before being partially reversed. These are not abstract risks; they enter a production budget before a single level is built.
What the engine actually gates
A licensed engine delivers a known quantity: a rendering pipeline, a physics solver, an audio graph and, crucially, platform integration layers that have already been through certification. The Technical Requirements Checklist that every submission must pass includes threading behaviour, memory allocation discipline and suspend-resume handling, and an engine vendor shoulders the work of keeping those layers compliant as the platform holder issues new TRC revisions. For a studio without deep platform expertise, that is significant value — not glamour, but calendar time recovered.
An in-house engine offers something different: the ability to make the entire stack visible and modifiable. When a game's core mechanic demands control over memory layout, or when a team is trying to extract the last few frames from a fixed thermal budget, the capacity to reach into the renderer and change how draw calls are batched is not cosmetic. Studios that built proprietary engines — id Software's id Tech line, the internal technology behind Decima at Guerrilla Games, Insomniac's proprietary engine — accumulated that investment across multiple titles. The cost was front-loaded years earlier. A new studio cannot replicate it on a single project's budget.
That front-loading is the structural fact the engine decision turns on. Building a proprietary renderer, animation system and toolchain costs engineering years that produce no content. A publisher funding a first project rarely accepts that trade; a first-party studio, backed by a platform holder, sometimes can. This is part of why internal studios and their consolidation matter structurally: they can absorb engine investment that an independent studio cannot.
The platform as a third constraint
The engine choice also intersects with the platform in ways that licensed tools simplify. Development kit access, debugging APIs and performance-analysis tooling are often integrated into commercial engines before independent developers receive them. An in-house engine team must write those integrations themselves, which requires either early platform access — itself gated by the developer programme — or a later and more compressed integration sprint.
Backward compatibility adds another dimension. Running software across hardware generations involves licence arrangements as much as silicon, and an engine that has been forward-ported once has a documented path for doing it again. Engines that predated shader-model transitions or had threading models incompatible with multicore console architectures were sometimes abandoned not because the underlying game was wrong but because the runtime could not be moved forward economically.
The day-one patch sits at the far end of the same timeline. Certification occupies weeks before a title ships, and defects discovered in that window cannot be fixed on disc. Engine-level bugs — memory leaks, crash paths under specific suspend sequences — are among the hardest to close quickly, because fixing them requires understanding a system that may not have been written by anyone still at the studio. The engine does not just decide what a team can attempt at the start of a project; it is a part you can point at at every gate afterward.
