The question
If you want to learn programming for Unity in this wiki, the default route is: csharp-variables-and-types through the rest of the C# basics, then the C# OOP pages, then the Unity scripting core pages, and only after that the more specialised tracks such as AI, simulation, architecture patterns, Git workflow, and C++. Readers with prior C# or .NET experience can enter later, but most students should treat this page as the top-level map of the programming section.
The learning path
The programming topics form five sequential stages. Each stage assumes the previous one. Different readers can enter at different points depending on their background.
Stage 1 — C# language basics
These pages cover the language itself, independent of Unity. Complete beginners should read all five in order. Programmers coming from Python, JavaScript, or GDScript should skim them to note C#-specific syntax before moving to Stage 2.
| Order | Page | What it establishes |
|---|---|---|
| 1 | csharp-variables-and-types | Data types, declaration, const, arrays, public/private |
| 2 | csharp-control-flow | if/else, loops, switch — the logic skeleton of any script |
| 3 | csharp-methods | How to organise code into reusable named operations |
| 4 | csharp-enums | Named constants — essential for game state machines |
| 5 | csharp-properties | Encapsulated get/set access; used throughout Unity APIs |
Why this order? Types before control flow, control flow before methods, methods before the more complex OOP topics. Enums and properties are simpler than classes and are used immediately in Unity.
Stage 2 — C# object-oriented programming
Unity scripts are classes. Understanding OOP is required before Unity scripting makes sense.
| Order | Page | What it establishes |
|---|---|---|
| 6 | csharp-oop-fundamentals | Classes, objects, constructors, encapsulation, struct vs class |
| 7 | csharp-collections | List<T> and Dictionary<K,V> — the containers you will use constantly |
| 8 | csharp-inheritance | Base/derived classes, virtual/override, polymorphism |
| 9 | csharp-interfaces | Contracts (IDamageable, IInteractable) — the clean alternative to inheritance chains |
Why this order? OOP fundamentals before inheritance, inheritance before interfaces. Collections appear early because you will use List<T> in almost every Unity script.
Entry point for C# / .NET programmers: skip Stages 1–2 entirely and enter at Stage 3.
Stage 3 — Unity core scripting
The foundation of every Unity script: the MonoBehaviour lifecycle, Inspector wiring, and moving things around.
| Order | Page | What it establishes |
|---|---|---|
| 10 | monobehaviour-lifecycle | Start, Update, FixedUpdate, frame-rate independence |
| 11 | unity-inspector-references | SerializeField wiring; how scripts connect to GameObjects |
| 12 | unity-getcomponent | Accessing other components at runtime; caching pattern |
| 13 | unity-transform | Position, rotation, scale; moving objects under script control |
| 14 | unity-input | Reading keyboard/controller input |
Why this order? The lifecycle comes first because it governs when everything else runs. Inspector references come before GetComponent — you need to know both ways to connect scripts. Transform and input are the first things you actually use.
Stage 4 — Physics and interaction
Adding physical behaviour and collision detection.
| Order | Page | What it establishes |
|---|---|---|
| 15 | unity-rigidbody2d | Physics-based movement, forces, velocity, FixedUpdate |
| 16 | unity-collider2d-and-triggers | Detecting overlap and collision; OnTriggerEnter2D/OnCollisionEnter2D |
Note: read monobehaviour-lifecycle before unity-rigidbody2d — FixedUpdate is introduced there and is critical for physics scripts.
Stage 5 — Architecture patterns
Patterns for organising larger projects: how scripts talk to each other, how objects are spawned and tracked, how game state is managed.
| Order | Page | What it establishes |
|---|---|---|
| 16 | unity-object-communication | Reference + method call; avoiding fat classes |
| 17 | unity-prefabs-scripting | Instantiate, tracking spawned objects, batch operations |
| 18 | unity-gamemanager-pattern | Singleton, DontDestroyOnLoad, central state ownership |
| 19 | unity-animator-scripting | Animation state machine control from code |
| 20 | unity-audiosource | Sound playback, BGM, one-shot effects |
| 21 | unity-particle-system-scripting | Particle effects triggered by gameplay events |
Items 19–21 are independent of each other and can be read in any order or on demand.
Version control — read early, use throughout
These pages do not depend on programming knowledge and can be read any time before your first commit. Ideally: after Stage 1, before starting a real project.
| Page | What it establishes |
|---|---|
| git-concepts | The mental model: snapshots, three areas, local operations |
| git-workflow | Daily commands: status, add, commit, push, pull |
| git-branching | Branches, merge, conflict resolution |
| git-github-unity | Remote repos, .gitignore for Unity, Pull Requests |
Read in order. git-concepts is prerequisite to everything else here.
C++ — secondary path (Unreal Engine context)
These pages are for students moving toward Unreal Engine, or who need to understand why C# works the way it does by comparison. They are not required for Unity development.
They are self-contained relative to the C# path above but build on each other internally:
| Order | Page | What it establishes |
|---|---|---|
| 1 | cpp-basics | Types, pointers, references, value semantics — the core C# vs C++ contrast |
| 2 | cpp-classes-and-oop | Classes, virtual functions (not default — key difference from C#), RAII destructors |
| 3 | cpp-memory-management | RAII, unique_ptr/shared_ptr, move semantics — the alternative to garbage collection |
| 4 | cpp-templates | Generic types and functions; lambdas; concepts (C++20) |
Entry point for the C++ path: recommend at least Stage 2 of the Unity/C# path first, so the C# comparisons in the C++ pages are meaningful.
Entry points by background
| Background | Recommended entry |
|---|---|
| Never programmed before | Stage 1, page 1 — csharp-variables-and-types |
| Knows Python or JavaScript | Stage 1 skim for syntax, then Stage 2 |
| Knows C# from .NET / other context | Stage 3 — monobehaviour-lifecycle |
| Knows Unity but not architecture patterns | Stage 5 — unity-object-communication |
| Moving to Unreal Engine | C++ path, after completing Stages 1–2 |
What is not yet covered
The following topics are referenced in the pages above but do not yet have their own wiki pages:
- Unity animator (state machine editor) — the Animator Controller window, transitions, blend trees (scripting is covered in unity-animator-scripting but the editor workflow is not)
- C++ error handling — exceptions and invariants from Stroustrup Ch. 4
- C++ STL containers —
vector,map,unordered_map(Stroustrup Ch. 12) - Unity UI scripting — Canvas, EventSystem, Button.onClick
- Unity coroutines —
IEnumerator,StartCoroutine,yield return
Related
overview-unity-2d-architecture | unity-input-system | unity-scriptableobjects | source-cre132-labs | source-csharp-yellow-book | source-a-tour-of-cpp