How Unity
actually works
Not a click-here-then-there video course. Each topic explains one idea properly, shows the C# that goes with it, and links to scripts you can drop straight into a project.
Who this is for
This guide assumes you can already write a little code, and that what you actually need is Unity's model of the world: what a GameObject is, why components matter more than class hierarchies, and which of Unity's many ways to do a thing is the right one.
Read it in order
The topics build on each other. Components come before transforms, transforms before physics, because that is the order the ideas actually depend on each other.
Then use the code
Every topic links to working scripts from the script library and the complete game systems, so you can go from understanding an idea to shipping it in the same sitting.
Topics
15GameObjects & Components
The one idea Unity is built on
Understand the GameObject and Component model that everything else in Unity sits on top of, and why Unity favours composition over inheritance.
The Transform
Position, rotation, scale, and parenting
How Unity positions objects in space, the difference between local and world coordinates, and why you should never set scale on a physics object.
Prefabs & Variants
Reusable objects that stay in sync
How prefabs let you define an object once and reuse it everywhere, how overrides and variants work, and how to spawn prefabs from code without hurting performance.
The MonoBehaviour Lifecycle
Awake, Start, Update, FixedUpdate
What Unity calls and when, why Awake and Start are not interchangeable, and how to pick between Update, FixedUpdate, and LateUpdate.
Colliders & Rigidbodies
How Unity decides what touches what
The difference between colliders and rigidbodies, why collisions sometimes do not fire, triggers vs collisions, and how to move physics objects correctly.
ScriptableObjects
Data that lives outside the scene
What ScriptableObjects are, why they beat prefabs and singletons for shared data, and the one runtime gotcha that surprises everyone the first time.
Scenes & Loading
Additive scenes and scene flow
How Unity scenes work, loading them asynchronously without freezing the game, additive loading, and keeping objects alive between scenes.
Canvas & UI
Anchors, scaling, and layout groups
How Unity UI works: canvas render modes, why anchors decide whether your UI survives other screen sizes, and how to stop the canvas rebuilding every frame.
The Input System
Actions, maps, and device support
The difference between Unity's old and new input systems, how actions and action maps work, and how to support keyboard, gamepad, and touch without branching code.
Coroutines & Async
Doing things over time
How coroutines work, the yield instructions worth knowing, when they silently stop, and when async/await is the better tool.
Grids & Tilemaps
Snapping a world to a lattice
How Unity grids and tilemaps work, converting between world and cell coordinates, and building your own grid for placement, inventories, and tactics games.
Inventory Systems
Items, stacks, and slots that survive a save
How to structure a Unity inventory: separating item definitions from runtime stacks, handling stacking and slots, and keeping the UI in sync without coupling it to the data.
Saving & Loading
Getting state onto disk without losing it
PlayerPrefs versus JSON versus binary, where save files actually belong on each platform, and how to version a save format so old saves keep working.
State Machines
Taming "is jumping and also dead"
Why boolean flags stop scaling, how to build a clean state machine for players and enemies, and when Unity's Animator should own state instead of your code.
Events & Decoupling
Letting systems talk without knowing each other
C# events, UnityEvents, and ScriptableObject event channels compared, plus the subscription leak that causes most "MissingReferenceException" crashes.