Unity Game Engine: The Complete Guide

If you are choosing a game engine in 2026, Unity is almost certainly on your list — it is the engine that put a generation of indie and mobile games on the map. It is broad, battle-tested, and backed by an ecosystem nothing else can match. It is also the engine whose 2023 pricing controversy taught the whole industry to read the licensing terms carefully. This guide explains what Unity is, how its pricing actually works today, what it is good (and not good) at, how it compares to Godot and Unreal, and exactly how to get from a blank editor to a running, shippable game.

What is the Unity game engine?

Unity is a cross-platform game engine for building 2D and 3D games and interactive applications. First released in 2005 by Unity Technologies, it bundles a scene editor, a 2D and 3D renderer, a physics engine, animation, audio, a UI system, a particle system, and export tooling into one application. You assemble games visually and script their behavior in C#, then build to a remarkably wide set of platforms from a single project.

Unity began life as a Mac-only engine and grew into the default choice for an entire wave of indie and mobile developers, in large part because it lowered the barrier to shipping on many platforms at once. Today the editor itself runs on Windows, macOS, and Linux. Unlike Godot, Unity is closed source — the engine is proprietary, with source access available only on enterprise-level licenses — but it is backed by a large company, a vast official tutorial library, and the biggest third-party ecosystem in the industry.

Is Unity free? Pricing and the Runtime Fee

Unity Personal is free below a revenue and funding eligibility cap; above it, you pay for a seat-based subscription. Unity does not use the flat, royalty-free model that an MIT-licensed engine like Godot does — it uses tiered, per-seat subscriptions. As of 2024/2025, the structure looks like this (always confirm current terms on unity.com, because Unity has changed them before):

• Unity Personal is free for individuals and small teams whose annual revenue and raised funds stay below an eligibility cap. That cap has been raised over time — historically to around USD $200,000. Below it, you can ship commercial games at no cost.
• Unity Pro and Unity Enterprise are paid seat-based subscriptions for studios above the free threshold, adding features, support, and (on Enterprise) source access.
• No per-install fee. Unity charges per seat, not per copy of your game sold or installed.

The Runtime Fee, and why it was canceled

In September 2023 Unity announced a per-install "Runtime Fee" — a charge tied to the number of times a game was installed past certain thresholds. The backlash from developers was severe: the fee was widely seen as unpredictable, retroactive in spirit, and impossible to budget around. In September 2024, Unity canceled the Runtime Fee entirely and returned to its seat-based subscription model. As of 2024/2025, there is no per-install charge. The episode is worth remembering not because the fee still applies — it does not — but as a reminder that, with a closed-source engine, pricing is set by a company that can revise it. Read the current terms before you commit a multi-year project.

What can you build with Unity?

Unity is a true general-purpose engine, and its breadth is the whole point.

Mobile games

Unity has long been the dominant engine for mobile. Its export pipeline to Android and iOS is mature, its performance scales down to modest hardware, and a huge share of the App Store and Google Play catalog runs on it. Hits like Among Us and Pokémon GO are Unity games. If you are targeting phones, Unity is a safe, well-trodden choice.

2D games

Unity's 2D toolset — sprites, tilemaps, a 2D physics system, and the Sprite Editor — is solid and has shipped many acclaimed titles, including Hollow Knight, Cuphead, and Ori and the Blind Forest. It is not as purpose-built for 2D as Godot or GameMaker, but it is more than capable, and the asset ecosystem fills most gaps.

3D games

Unity handles stylized and mid-range 3D very well, and with the High Definition Render Pipeline it can push toward high fidelity. Genshin Impact and Cities: Skylines show how far Unity 3D scales in the right hands. For the absolute top tier of photorealistic AAA visuals, Unreal Engine is still the more proven default, but Unity covers an enormous middle ground.

VR, AR, and beyond

Unity is the default engine for a large slice of VR and AR development — Beat Saber is a Unity game — and it is used well beyond games, for architecture, automotive, film previsualization, and simulation. The same editor that ships a mobile puzzle game can drive an industrial training app.

How Unity works: GameObjects and Components

Unity's core mental model is composition: you build behavior by attaching small, single-purpose Components to GameObjects, rather than configuring one large object. Once that clicks, most of the editor makes sense.

GameObjects

A GameObject is the basic entity in a Unity scene — a player, an enemy, a camera, a light, an empty container. On its own a GameObject does almost nothing; it is a holder for Components. Every GameObject has at least a Transform Component, which stores its position, rotation, and scale.

Components

A Component is a piece of functionality you add to a GameObject. A Rigidbody gives it physics, a Collider gives it a physical shape, a MeshRenderer draws it, an AudioSource plays sound, and your own C# scripts are Components too. You assemble a working object by stacking the Components it needs. This composition model is the heart of how Unity is designed.

Scenes and Prefabs

A Scene is a container for a set of GameObjects — a level, a menu, a loading screen. A Prefab is a reusable GameObject template saved as an asset: build an enemy once as a Prefab, then drop dozens of instances into a scene, and edits to the Prefab propagate to every instance. Prefabs are Unity's answer to reuse, much like instanced scenes in other engines.

DOTS and ECS (the advanced path)

For performance-critical games that need to simulate huge numbers of entities, Unity offers DOTS (the Data-Oriented Technology Stack) and its Entity Component System (ECS). ECS replaces the object-oriented GameObject model with a cache-friendly, data-oriented layout that can scale to massive simulations. It is a more advanced, higher-effort path — most projects start and stay on the classic GameObject-Component model — but it exists when you need raw throughput.

C# and MonoBehaviour scripting

Unity's scripting language is C#. The older UnityScript (a JavaScript-like language) was removed years ago, so all modern Unity development is in C#. Your scripts are Components: most of them inherit from MonoBehaviour and hook into Unity's lifecycle through specially named methods that the engine calls for you:

• Awake — called once when the object loads, before anything else; used for early setup.
• Start — called once before the first frame, after all Awake calls; used for setup that depends on other objects.
• Update — called every frame; the place for most per-frame logic and input handling.
• FixedUpdate — called on a fixed timestep; the correct place for physics (Rigidbody) work.

Here is a minimal player mover that reads input each frame and applies it to a CharacterController:

using UnityEngine;

public class PlayerMover : MonoBehaviour
{
    public float speed = 5f;

    private CharacterController controller;

    // Awake runs once when the object loads
    void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    // Update runs every frame
    void Update()
    {
        float x = Input.GetAxis("Horizontal");
        float z = Input.GetAxis("Vertical");
        Vector3 move = new Vector3(x, 0f, z);
        controller.Move(move * speed * Time.deltaTime);
    }
}

Attach that script to a GameObject as a Component, give the object a CharacterController, and the speed field shows up in the Inspector for designers to tweak without touching code. That tight loop between code, the Inspector, and live Play Mode is a big part of why Unity feels productive. For deeper performance, Unity also compiles C# through its Burst compiler and supports the IL2CPP backend that converts your code to C++ for shipping builds.

Render pipelines and platforms

Unity ships three render pipelines, and you pick one per project based on the visual fidelity and hardware range you are targeting:

Unity's platform reach is one of its strongest selling points. From a single project you can export to Windows, macOS, Linux, Android, iOS, and WebGL — and, crucially, to the major consoles with official support: Nintendo Switch, PlayStation, and Xbox, delivered through platform modules. That first-party console pipeline is a genuine advantage over open-source engines like Godot, which depend on third-party porting companies because console SDKs are closed and under NDA.

Notable version history

Unity has been shipping for two decades, so a little history helps when you read tutorials of different ages.

• 2005: Unity 1.0 launches as a Mac-only engine at Apple's Worldwide Developers Conference.
• Late 2000s onward: Unity expands to Windows and a growing list of mobile and console platforms, becoming the default engine for indie and mobile development.
• C# consolidation: Unity supported multiple scripting languages early on, but UnityScript and Boo were deprecated and removed, leaving C# as the single scripting language.
• Scriptable Render Pipelines: URP and HDRP were introduced to replace the aging Built-in pipeline with modern, customizable rendering.
• September 2023: Unity announces the per-install Runtime Fee, triggering an industry-wide backlash.
• September 2024: Unity cancels the Runtime Fee and returns to seat-based subscription pricing.
• Late 2024: Unity 6 is released, the current major line, with rendering and performance improvements and a renewed focus on stability after the pricing turmoil.

Because the engine is so long-lived, you will find tutorials targeting many versions. When following one, check which Unity version and render pipeline it assumes — APIs and the editor layout have shifted over time.

Unity vs Godot vs Unreal

This is the comparison most people are really searching for. Here is an honest, high-level breakdown. The right answer depends on your project, your team, and your budget.

Short version: pick Unity for the largest ecosystem, official console support, and the deepest hiring pool; pick Godot for 2D games, small teams, and a transparent fee-free license; pick Unreal for top-tier 3D fidelity and built-in console pipelines.

How to download and install Unity

Unity is installed through Unity Hub, a manager that handles editor versions, modules, and projects.

1. Go to the official site, unity.com, and download Unity Hub for your operating system.
2. Create or sign in with a free Unity account and choose a plan (Personal is free if you are under the revenue/funding eligibility cap).
3. In Unity Hub, open the Installs tab and install a recent LTS (Long-Term Support) version of the editor — LTS releases are the most stable for real projects.
4. When installing, add the build support modules you need (Android, iOS, WebGL, and so on). You can add more later.
5. Switch to the Projects tab to create or open a project.

System requirements are heavier than a lightweight engine: Unity benefits from a reasonably modern CPU, a decent GPU, plenty of RAM, and a fair amount of disk space per editor version and platform module. A mid-range development machine handles it comfortably.

How to make your first game in Unity

Here is the shortest path from zero to a running, buildable game. None of these steps require paid assets.

1. Create a project. In Unity Hub, click New Project, choose a template (2D, 3D, or a URP template), name it, and open the editor.
2. Build a scene. In the Scene view, add GameObjects — a ground plane, a player, and a camera. Give the player a CharacterController or a Rigidbody and a Collider so it has shape and physics.
3. Attach a C# script. Create a new C# script, drag it onto the player GameObject to add it as a Component, and paste the movement code from the C# section above. Tweak the public speed field right in the Inspector.
4. Set up input. Wire up your controls — the classic Input axes (Horizontal/Vertical) work out of the box, or use the newer Input System package for more control.
5. Press Play. Click the Play button to enter Play Mode, test live, adjust values in the Inspector, and read the Console window for errors and logs.
6. Build it. Open File > Build Settings (or Build Profiles), add your scenes, pick a target platform, and build a standalone executable you can hand to a friend or upload to itch.io.

From there, the loop is the same as in any engine: add GameObjects and Prefabs, attach Components and scripts, test in Play Mode, and iterate. Unity's live Play Mode and Inspector tweaking make experimentation fast once you are comfortable with the layout.

Pros and cons of Unity

Games made with Unity

Unity's track record spans nearly every genre and platform. Acclaimed and commercially huge games built with it include Hollow Knight, Cuphead, Ori and the Blind Forest, Cities: Skylines, Among Us, Genshin Impact, Pokémon GO, Hearthstone, and Beat Saber. That list runs from hand-drawn 2D platformers to massive open-world RPGs, city-builders, mobile and AR phenomena, and VR — a clear signal of just how broad Unity's range is in real production.

Learning Unity: a roadmap

A sensible path for a newcomer:

1. Start with Unity Learn, Unity's official free tutorial platform. The guided "first project" paths teach GameObjects, Components, and the editor in one sitting.
2. Learn C# basics — variables, methods, classes — and the MonoBehaviour lifecycle (Awake, Start, Update, FixedUpdate).
3. Rebuild a simple known game (Pong, a platformer, a top-down shooter) to internalize the GameObject/Prefab/Component pattern.
4. Pick a render pipeline and stick with it (URP is a good default for most projects) so tutorials and assets line up.
5. Ship something small. Build it, put it on itch.io, and watch how it behaves on hardware that is not yours. That last step teaches more than any tutorial.

If you build with Unity, our Unity solutions page walks through how to wire crash and bug reporting into a Unity project, and the Bugnet blog goes deep on the engines around it. When you are weighing your options, our best game engines guide compares them side by side.

Shipping a Unity game: the part tutorials skip

Building the game is one thing; keeping it stable once real players have it is another. A Unity game that runs flawlessly in the editor can still crash on a player's older Android device, a specific GPU driver, a platform you never tested, or a save file in a state you never hit. When that happens, a Steam review that just says "crashes on launch" gives you nothing to act on.

The bug you can't reproduce isn't gone — it's just invisible until you capture it from the player's device.

The fix is to capture failures automatically from the player's machine. With the right reporting in place, each crash or unhandled exception arrives with its full stack trace, the device and OS, the build number, and a breadcrumb trail of what the player did right before it broke. Identical failures fold into a single grouped issue ranked by how many players each one hits, so your worklist sorts itself worst-first instead of arriving as a stream of vague complaints.

That is exactly what Bugnet does for Unity games: a small SDK captures every error with full context, groups duplicates, and ties each issue to the build it first appeared in — so you fix the problem that hurts the most players first and confirm it is gone when its signature disappears from the next release. It is the difference between guessing at a bad review and shipping a fix you can prove worked.

Compare other game engines

Still deciding? These companion guides go just as deep on the other major engines, and our hub compares them side by side:

• Best game engines for indie developers — the side-by-side comparison and decision guide.
• Godot game engine — free, open-source, great for 2D and indie.
• Unreal Engine — best-in-class high-end 3D.
• GameMaker — fast, focused 2D development.
• Construct 3 — no-code, browser-based 2D.
• Pygame — Python library for learning game development.

Frequently asked questions

What is the Unity game engine?

Unity is a cross-platform game engine first released in 2005 by Unity Technologies. It is used to build 2D and 3D games and interactive applications, scripted in C#, and exports to a very wide range of platforms including Windows, macOS, Linux, Android, iOS, WebGL, and the major consoles. It is best known for its enormous asset store, large tutorial base, and the biggest hiring pool of any engine.

Is Unity free?

Unity Personal is free to use below a revenue and funding eligibility cap, which has historically been raised over time (to around USD $200K). Above that threshold you need a paid plan. Unity sells seat-based subscription tiers (Pro and Enterprise) on top of the free tier. As of 2024/2025 there is no per-install fee. Pricing details change, so confirm current terms on unity.com.

Did Unity cancel the Runtime Fee?

Yes. The controversial per-install Runtime Fee that Unity announced in September 2023 was canceled in September 2024. Unity returned to its seat-based subscription model with free Personal and paid Pro and Enterprise tiers. As of 2024/2025 developers are not charged per install.

What language does Unity use?

Unity uses C# as its scripting language. You write MonoBehaviour scripts with lifecycle methods such as Awake, Start, Update, and FixedUpdate. The older UnityScript (a JavaScript-like language) was removed years ago, so all modern Unity development is in C#.

Is Unity good for beginners?

Unity is one of the most beginner-friendly professional engines because of its huge tutorial base, large community, and the readable C# language. The GameObject-and-Component model is approachable, and the Asset Store lets newcomers buy or download ready-made art and systems. Its biggest learning curve is the sheer breadth of features and the choice between render pipelines.

Is Unity better than Godot?

Neither is strictly better; they fit different needs. Unity wins on ecosystem: a huge asset store, the largest tutorial base, official console support, and the biggest hiring pool. Godot wins on price (free, MIT, no royalties), a lightweight editor, an open-source codebase, and a first-class 2D engine. For studios that need console ports, third-party assets, or to hire experienced developers, Unity is often the better choice.

Can Unity make console games?

Yes. Unity offers official console support for Nintendo Switch, PlayStation, and Xbox through platform modules, in addition to Windows, macOS, Linux, Android, iOS, and WebGL. Official first-party console pipelines are a real advantage over open-source engines like Godot, which rely on third-party porting companies.

What games were made with Unity?

Many well-known games were built with Unity, including Hollow Knight, Cuphead, Ori and the Blind Forest, Cities: Skylines, Among Us, Genshin Impact, Pokémon GO, Hearthstone, and Beat Saber. They span 2D platformers, simulations, mobile hits, and VR, which shows how broad Unity's range is.

Pick the engine that gets you shipping. For multi-platform and mobile projects, that engine is often Unity — and the rest is just keeping it stable once players have it.