How Game Engines Work: Unity vs Unreal Explained
Photo: www.kaboompics.com / Pexels
A game engine is the piece of software that stands between a developer's idea and a working game: it manages the loop that reads your controller input, moves every object in the world, and draws a new picture on screen, over and over, dozens of times per second. Two companies, Unity Technologies and Epic Games, now dominate that market so completely that "which engine did you use" has become a defining question for almost every new studio. This article explains what an engine actually does, how its major subsystems fit together, and why the business decisions behind Unity and Unreal — licensing fees, scripting languages, architecture choices — end up shaping the games you play as much as any artist's decision does.
What a game engine actually is
A game engine is not one program. It is a bundled collection of subsystems — a game loop, a rendering pipeline, a physics solver, an audio mixer, an asset pipeline, a scripting runtime, and an editor — that together let a small team ship something that would otherwise require building an entire piece of infrastructure from scratch. Before general-purpose engines existed, studios wrote bespoke code for every title; id Software's Doom and Quake engines in the 1990s were among the first pieces of game code deliberately licensed out to other studios as reusable "engines," which is where the term stuck.
At the center of every engine sits the game loop, a cycle that runs continuously while the game is active. Each pass through the loop is a frame, and during that frame the engine has to poll input devices, advance physics and AI simulations, run whatever scripts the developer wrote, and then hand a finished set of drawing instructions to the graphics processor. At 60 frames per second, the entire loop has to complete in about 16.7 milliseconds; competitive titles that target 144 fps or higher give the engine under 7 milliseconds to do the same work. Miss that budget even occasionally and the player feels it as stutter or input lag, which is why engine performance is treated as a first-class design constraint, not an afterthought.
Beyond the loop, an engine also owns the asset pipeline (importing 3D models, textures, animations, and audio and converting them into optimized runtime formats), the scene graph (a hierarchy of objects and their parent-child spatial relationships), and the editor, the visual application where designers place objects and tune values without recompiling code. None of these pieces is glamorous, but collectively they are why a three-person indie team can ship a game that would have needed a fifty-person studio and a custom engine twenty years ago.
The two companies behind the two engines
Unity Technologies and Epic Games arrived at their current dominance from very different starting points, and understanding that history explains a lot about why the two engines feel so different to use today.
Unity: from a failed indie game to a developer platform
Unity started life as Over the Edge Entertainment, a small Danish studio founded in Copenhagen on August 2, 2004, by David Helgason, Nicholas Francis, and Joachim Ante. Their first game, GooBall, released in 2005 and sold poorly, but the founders noticed that the internal tools they had built to make GooBall were more valuable than the game itself. They pivoted the company to sell that toolset, renamed it Unity, and set out to "democratize" game development — their words — by making a capable 3D engine cheap and approachable enough for solo developers and small teams. (Wikipedia, Nordic Startup News)
That founding bet paid off. Former Electronic Arts CEO John Riccitiello took over as Unity's CEO in 2014 and pushed the company toward mobile gaming and enterprise licensing, and Unity went public on the New York Stock Exchange in September 2020. (Wikipedia) Today, industry analytics firm Sensor Tower estimates Unity powers 71% of the top 1,000 mobile games and around 65% of the hyper-casual segment specifically, a niche where Unity's small runtime footprint and rapid iteration cycle matter more than cutting-edge visuals. (Sensor Tower)
Epic Games: a shooter studio that decided to sell its plumbing
Unreal Engine's history runs the other direction. Epic Games built the engine to ship its own first-person shooter, Unreal, in 1998, and only afterward realized the underlying technology was worth licensing to other studios — a business model closer to id Software's Doom and Quake engines than to Unity's tools-first approach. Epic kept iterating on that engine through three more generations while also building Fortnite, which became one of the highest-grossing games in history and gave Epic an enormous war chest to fund Unreal's development independent of licensing revenue.
That war chest matters, because it lets Epic treat Unreal Engine partly as a loss leader for its broader platform ambitions (the Epic Games Store, the Unreal Editor for Fortnite, and Epic's ongoing legal fight with Apple over app store fees). Unreal Engine 5, released in 2022, is widely regarded as the current benchmark for real-time visual fidelity in AAA production, and Epic has been actively courting studios away from expensive proprietary engines: one industry analysis found that building and maintaining a custom engine can add 18 to 24 months to a project's development timeline, a delay that frequently costs a studio more than Unreal's royalty ever would.
Licensing: the fee structures that shape who uses what
The most consequential difference between Unity and Unreal in 2026 is not a graphics feature. It is money, and specifically how each company gets paid.
Unreal Engine is free to download and use, and Epic only takes a cut once a shipped product earns more than $1 million in lifetime gross revenue, after which a royalty applies to everything above that threshold. As of January 1, 2025, that royalty is 3.5% for titles launched on the Epic Games Store as part of Epic's "Launch Everywhere" initiative, while the standard 5% rate still applies to games that skip the Epic store entirely. (CG Channel, RocketBrush) Epic also introduced a separate seat-based Unreal Subscription, priced at roughly $1,850 per seat annually, aimed at non-game commercial users like architecture and film studios who want to license outright rather than pay a revenue share. (Practice Test Geeks)
Unity's pricing has been far more turbulent. In September 2023, Unity announced a "Runtime Fee" that would have charged developers a small amount, up to $0.20, per game install once a title crossed certain revenue and install thresholds — a structure developers immediately criticized because it charged per copy regardless of whether that copy ever generated revenue, and because it applied retroactively to games already shipped. The backlash was severe enough that Unity fully canceled the Runtime Fee less than a year later, in September 2024, and reverted to its older per-seat subscription model instead. (Unity, The Register) Under the pricing that took effect January 1, 2025, Unity Pro rose 8% to roughly $2,200 per seat annually, Unity Enterprise rose 25%, and Unity Personal (the free tier) stayed free while its revenue ceiling doubled from $100,000 to $200,000. (CG Channel)
The following table summarizes the current licensing landscape as of mid-2026.
| Model | Unity | Unreal Engine |
|---|---|---|
| Free tier | Unity Personal, up to $200,000 annual revenue | Free for all revenue up to $1 million |
| Paid structure | Per-seat annual subscription (Pro/Enterprise) | Revenue royalty above $1 million (3.5–5%) |
| Approx. cost at scale | ~$2,200/seat/year (Pro, 2025 rate) | 3.5–5% of gross revenue above $1M threshold |
| Non-game commercial licensing | Included in standard tiers | Separate ~$1,850/seat Unreal Subscription |
| 2023–2025 controversy | Runtime Fee proposed, then canceled | None comparable |
Table: Licensing comparison between Unity and Unreal Engine, current as of early 2026 pricing changes.
The practical effect is that a studio expecting modest, install-heavy revenue (free-to-play mobile, hyper-casual) tends to prefer Unity's predictable per-seat cost, while a studio expecting a smaller number of high-value sales (premium PC and console titles) tends to prefer Unreal's revenue-share model, since most projects never cross the $1 million royalty threshold at all.
Why did Godot's popularity spike so sharply in 2023?
Godot is a free, open-source engine with no licensing fee or royalty of any kind. When Unity announced its per-install Runtime Fee in September 2023, thousands of developers who had never seriously evaluated alternatives began prototyping in Godot as a hedge, and the engine's GitHub star count and active user base both grew at multiples of their historical rate within weeks. (Game World Observer)
Architecture: how objects and behavior are organized
The way an engine structures a game's data internally is not a cosmetic detail — it determines how many objects a game can simulate at once and how fast the engine can update them every frame.
Object-oriented game objects: the older model
Classic engine architecture models each game object — a character, a crate, a bullet — as a single object that bundles both its data (position, health, inventory) and its behavior (how it moves, how it reacts to damage) together, typically through inheritance hierarchies. This is intuitive to reason about and matches how most programmers are taught object-oriented design, but it scales poorly. Objects of different types end up scattered across memory in whatever order they were created, so when the engine needs to update, say, every object's position, the CPU has to jump around memory unpredictably, which is slow on modern hardware because of how CPU caches work.
Entity-Component-System: the modern answer
Entity-Component-System (ECS) solves that memory-layout problem by splitting an object into three separate concepts: an entity is just an ID number, a component is a plain block of data (a position, a velocity, a health value) with no attached behavior, and a system is a function that processes every component of a given type in one tight loop. Rather than 10,000 characters each individually deciding how to move, one movement system processes 10,000 position components stored contiguously in memory, which the CPU can stream through far faster than it can chase pointers around a scattered heap.
ECS as a formal pattern traces back to game studios experimenting with it independently in the late 1990s and 2000s — Looking Glass Studios used an early version for Thief: The Dark Project in 1998, Scott Bilas of Gas Powered Games gave an influential 2002 talk on the pattern based on Dungeon Siege, and developer Adam Martin's widely read 2007 blog series formalized the vocabulary — "entities," "components," "systems" — that the industry still uses. (HandWiki) Unity adopted the pattern as its Data-Oriented Technology Stack (DOTS), introduced starting in 2018, which restructures Unity's traditional GameObject model into ECS for CPU-bound, large-scale simulations. Unreal Engine has its own comparable system called Mass Entity, used internally for large crowd and AI simulations, though most Unreal gameplay code still uses the older Actor/Component object model by default.
Scripting: C# versus Blueprints versus C++
How a developer actually writes gameplay logic diverges even more sharply between the two engines than their licensing does, and this is often the single biggest factor in which engine a given team picks.
Unity's primary scripting language is C#, run through either the Mono virtual machine or, for shipped builds, compiled ahead-of-time to native code through IL2CPP. C# is a mainstream, garbage-collected language already familiar to millions of web and enterprise developers, which is a large part of why Unity's learning curve is gentler than Unreal's for programmers coming from outside the games industry.
Unreal's primary language is C++, chosen because Epic needed maximum control over performance for its own AAA titles, but Epic also built Blueprints, a visual scripting system where a developer wires together logic nodes in a graph instead of typing text. Blueprints let designers and artists — people who are not primarily programmers — build and iterate on gameplay behavior directly, without waiting on an engineer to expose every variable, which is a major reason Unreal has become popular even outside traditional programming-heavy studios. Performance-critical systems in a shipped Unreal game are almost always still written in C++, with Blueprints handling higher-level glue logic, UI, and rapid prototyping.
Which scripting approach is faster to learn?
Unity's C# has a gentler on-ramp for anyone with prior programming experience, since it reads like a standard object-oriented language. Blueprints has a gentler on-ramp for non-programmers specifically, since it removes syntax entirely, but visual graphs become harder to manage than text code once a project's logic grows past a few hundred nodes.
The rendering pipeline: from geometry to pixels
Rendering is the engine's most visible job, and both Unity and Unreal ultimately do the same fundamental thing: convert a scene described as triangles into a 2D grid of colored pixels, dozens of times per second.
The CPU submits a list of triangles — the basic building block of any 3D model — to the GPU, and a vertex shader transforms each triangle's corner points from 3D world coordinates into 2D screen coordinates using matrix math. The GPU then figures out which pixels each triangle covers, a process called rasterization, and for every covered pixel a fragment shader calculates a final color by combining textures, material properties, and lighting. Modern engines typically use deferred rendering, which separates this into two passes: the first writes surface data (position, normal, material) into a set of off-screen buffers called the G-buffer, and the second uses that stored data to calculate lighting for every light source in the scene without re-processing the geometry a second time. This is what makes dozens of dynamic lights in a single scene computationally feasible.
Unity exposes this pipeline through its Scriptable Render Pipeline, split into the Universal Render Pipeline (URP, tuned for mobile and mid-range hardware) and the High Definition Render Pipeline (HDRP, tuned for high-end PC and console). Unreal Engine 5's headline rendering features — the Nanite virtualized-geometry system and the Lumen dynamic global illumination system — go deep enough to warrant their own dedicated coverage; see how game engines render lighting for the full mechanics of rasterization, physically based shading, and real-time global illumination.
Physics: simulating a world that behaves plausibly
Physics is fundamentally an exercise in useful approximation rather than accuracy. Solving the differential equations that govern true physical motion for a whole game world would be computationally impossible in real time, so physics engines use simplified models tuned to feel right rather than be exactly right.
Rigid body dynamics treats each object as a perfectly non-deforming shape with mass, velocity, and a collision shape that is usually much simpler than its visual mesh — a barrel might be visually detailed but collide as a plain cylinder. The engine integrates forces over time, typically using Verlet integration or similar numerical methods, to update every object's position each frame.
Collision detection runs in two stages. A cheap broad phase uses bounding boxes or spatial partitioning structures to quickly rule out object pairs that are obviously too far apart to touch, and a more expensive narrow phase then runs precise geometric checks only on the remaining candidates to find exact contact points. Constraint solving handles joints, hinges, and resting contacts by iteratively correcting velocities to stop objects from interpenetrating; the two dominant physics libraries, NVIDIA's PhysX (Unreal's default) and Havok, both use variants of a Sequential Impulse solver that converges toward a plausible result within a fixed number of iterations per frame, trading perfect accuracy for a guaranteed, predictable frame budget.
Platform reach and where each engine wins
Engine choice extends beyond code into where a game can actually ship and who wants to work on it.
Unity's cross-platform export list is unusually broad, covering iOS, Android, WebGL, every major console, PC, and VR/AR headsets from a single project, which is a large part of why Unity dominates mobile: an estimated 90% of 2D mobile games and a majority of the App Store's top charts run on it. (Sensor Tower) Unreal's platform reach is comparable technically, but its practical center of gravity is AAA console and PC development; Sensor Tower's 2025 engine report put Unreal at roughly 48% share of AAA titles specifically, against about 25% for Unity in that same premium segment, and noted Unreal powers a large majority of Sony's first-party console output. (Sensor Tower)
Notable Unity titles include Hollow Knight, Cuphead, Ori and the Blind Forest, Among Us, Pokémon Go, and Genshin Impact. Notable Unreal titles include Fortnite, Black Myth: Wukong, Hogwarts Legacy, and Senua's Saga: Hellblade II, along with Epic's own tech showcase, The Matrix Awakens.
What most players get wrong about engine choice
A common assumption is that a game's engine determines its visual quality outright — that "Unreal games look better." That is not really true. Nanite and Lumen give Unreal a higher visual ceiling out of the box, but a skilled Unity team using HDRP and custom lighting solutions can produce comparably striking results, and plenty of visually unremarkable games ship on Unreal every year. Engine choice is closer to choosing a construction toolkit than choosing a finished look — the artists and engineers using it still determine the outcome.
Another common misconception is that "free" and "royalty-free" mean the same thing. Unreal is free to download and use for prototyping, but it is not royalty-free once a title clears $1 million in revenue; conversely, Unity's per-seat subscription applies regardless of whether a game ever earns a cent, which is a fundamentally different kind of financial risk. A hobbyist prototyping on nights and weekends faces essentially zero cost either way; a studio betting on a hit product needs to model both structures against realistic revenue projections before choosing.
Finally, many players assume every major game runs on Unity or Unreal. Plenty of the largest titles in the industry do not: Rockstar's RAGE powers Grand Theft Auto and Red Dead Redemption, id Software's id Tech powers Doom, and Valve's Source engine powers Counter-Strike and Half-Life. These proprietary engines persist specifically because their studios have the scale to justify the multi-year investment a custom engine requires, and because deep vertical control over the engine can be a genuine competitive advantage for a studio making only one kind of game repeatedly.
FAQ
Q: Do all games use Unity or Unreal Engine? A: No. Major studios like Rockstar (RAGE), id Software (id Tech), and Valve (Source) maintain proprietary engines. Unity and Unreal dominate among indie, mid-size, and increasingly AAA studios because of their mature toolsets and the cost of building a custom engine from scratch.
Q: Is Unreal Engine actually free? A: Unreal Engine is free to download and use, and Epic Games only takes a royalty once a shipped title's lifetime gross revenue exceeds $1 million. As of January 1, 2025, that royalty is 3.5% for titles launched on the Epic Games Store and 5% otherwise. (CG Channel)
Q: What happened with Unity's Runtime Fee? A: In September 2023, Unity proposed charging developers per game install after certain thresholds, drawing widespread developer backlash for applying retroactively and charging regardless of revenue. Unity fully canceled the fee in September 2024 and returned to a per-seat subscription model with price increases effective January 1, 2025. (Unity)
Q: What is Entity-Component-System (ECS) and why does it matter? A: ECS is an architecture that separates game object data (components) from behavior (systems), storing similar data contiguously in memory instead of scattered across individual objects. This improves CPU cache efficiency dramatically, letting engines simulate far more objects per frame than traditional object-oriented designs.
Q: Should I learn C# or Blueprints first if I want to make games? A: If you already have programming experience or want fine-grained control, Unity's C# has a gentler learning curve because it's a standard text-based language. If you're a designer or artist without a programming background, Unreal's Blueprints visual scripting lets you build gameplay logic without writing syntax, though large projects typically still need C++ for performance-critical systems.
Q: What is the game loop and why does it matter? A: The game loop is the core cycle that runs every frame: process input, update world state, render. It determines how responsive and smooth a game feels; a poorly optimized loop causes frame drops and input lag.
Q: Why do games drop frames? A: Frame drops happen when one or more engine subsystems take longer than the frame's time budget. Common causes include too many draw calls, expensive physics calculations, CPU-GPU synchronization stalls, or garbage collection pauses in managed-language runtimes like Unity's C# environment.
Q: Why did so many developers switch to Godot in 2023? A: Godot is free and open-source with no licensing fee or royalty of any kind. When Unity announced its Runtime Fee in September 2023, developers looking to hedge or migrate away drove Godot's GitHub stars and active user base to roughly double within a month, a surge that had previously taken the engine about a year to achieve. (Game World Observer)
Q: Does the engine determine how good a game looks? A: Not entirely. Unreal Engine 5's Nanite and Lumen systems raise the visual ceiling out of the box, but a skilled team using Unity's HDRP pipeline can produce comparable results. Art direction and engineering skill matter as much as the underlying engine.
Q: Can I switch a project from Unity to Unreal (or vice versa) partway through development? A: Technically yes, but in practice it means rebuilding assets, rewriting all gameplay scripts in a different language, and re-learning the editor and rendering pipeline, so most studios treat engine choice as a decision made once, early, based on target platform, team skill set, and expected revenue rather than something to revisit mid-project.
The takeaway
A game engine's job is deceptively simple to describe — process input, update the world, draw a picture, sixty times a second — but every layer underneath that loop represents decades of accumulated engineering shortcuts, from ECS memory layouts to deferred rendering to approximate physics solvers. Unity and Unreal answer the same technical problems in different ways because they were built by different companies with different incentives: one selling accessibility to millions of small developers, the other subsidized by one of the most profitable games ever made. Understanding those incentives, not just the feature lists, is what actually explains why a mobile hit and a AAA console blockbuster so rarely come from the same engine choice.
Read next:
Follow new articles
Add SciHub101 to your feed reader to see new science and technology stories.
About the Author
SciHub101 is an independent science and technology publication founded and edited by Buğra Sözeri, a software engineer and app developer based in Türkiye. AI tools assist with drafting and research. Source documentation in the existing archive is uneven, and articles are being reviewed and corrected. The Editorial Team byline identifies editorial responsibility; it does not certify specialist or independent human review. Where we compare products, anything built by our own team is labelled as such — see the editorial guidelines and About page for how corrections and disclosures work.
Related Articles
Procedural Narrative Generation: Can AI Write Stories Worth Playing?
AI-powered narrative generation is enabling games to tell unique stories for every player, blending authored depth with procedural variety in ways previously impossible.
AI-Powered Game Testing: How Machine Learning Is Transforming Quality Assurance
AI testing agents can play through games thousands of times overnight, finding bugs and balance issues that human QA testers would take months to discover.
Game Sound Design: How Audio Creates Immersion
You hear a footstep above you in *Alien: Isolation* and your heart rate spikes before you consciously register what you heard. Game audio operates at the boundary of conscious and unconscious processing — and the science behind it is as sophisticated as anything in visual rendering.
History of Video Game Graphics: From Pong to Photorealism
Video game graphics have advanced further in 50 years than almost any other technology. The journey from two white rectangles bouncing a dot to real-time ray-traced worlds is a story of engineering leaps, creative constraints, and an endless push to make the virtual look real.
The Science of Speedrunning: How Glitches and Exploits Work
Completing a 50-hour game in 20 minutes sounds impossible, but speedrunners do it by exploiting the fundamental gap between what a game looks like and how it actually works in memory. Understanding how glitches work is essentially a course in low-level computer science.
Procedural Generation: How Minecraft Builds Infinite Worlds
Minecraft's world spans roughly 60 million blocks in each direction, yet it fits in a few bytes of seed data. The mathematics behind biomes, caves, and mountains from a single number is one of gaming's most elegant engineering achievements.