Technical notes for Unity game engine. All 99 articles are organized as a learning path you can follow in order, from fundamentals to advanced topics.
01Learn Unity's most fundamental concepts: the relationship between GameObjects and Components. Understand Unity's design philosophy of adding functionality to empty objects, explained for beginners.
02What is the MonoBehaviour class that appears in every Unity C# script? Learn its role and how to use convenient properties like transform and gameObject, explained for beginners.
03Learn when and in what order Unity scripts execute. A beginner-friendly, illustrated guide to the roles and differences of key event functions like Awake, Start, Update, FixedUpdate, and LateUpdate.
04C# is the language that powers Unity games. This article explains the essential C# fundamentals every Unity beginner should know: variables, data types, functions, and control flow statements.
05Still creating enemy1, enemy2, enemy3... as separate variables? Learn how arrays and Lists let you manage multiple pieces of data together, with practical Unity examples like spawn point management and enemy tracking. Beginner-friendly guide.
06You can copy sample code just fine, but freeze the moment you have to decide how to split your own scripts into classes — the wall most Unity beginners hit right after variables and functions. This guide covers classes and instances, value vs. reference types, null and Unity's special destroyed-object check, [SerializeField] private and properties, inheritance vs. composition, and interfaces — all the way to a working IDamageable example.
07Prefabs are among Unity's most important features for dramatically improving development efficiency. Learn everything from what Prefabs are, how to create and use them, to advanced topics like Nested Prefabs and Variants.
08File management techniques for avoiding chaos in large Unity projects. Covers the role of scenes and how to split them, the standard _Project folder pattern that separates your work from external assets, and how .meta files and GUIDs work (always move assets inside the Unity editor).
09Graduate from folder-copy backups and put your Unity project under real version control — so you can always get back to 'it worked yesterday.' Covers Force Text and Visible Meta Files, a Unity-specific .gitignore, why .meta files must be committed with their assets, when to move large binaries to Git LFS, and the standard rules for avoiding scene conflicts when working as a team.
10Learn to differentiate between Layers and Tags, control collision detection, and optimize Raycast with LayerMask for effective object management.
11Learn how to use Unity's New Input System. Implement cross-platform input handling using Input Actions, Bindings, and the Player Input component.
12You've read the basics, but a blank project still freezes you — this capstone bridges that gap. Build a 60-second coin-collecting game down one straight road: scene setup, Prefabs, input, trigger pickups, score and timer UI, Title/Playing/Result state flow, retry, and a build you can play outside the Editor. Assets are just Cubes and Spheres; the whole game is four scripts.
13How do you build that 'change key' button in your settings menu? A step-by-step guide to key rebinding with the New Input System's PerformInteractiveRebinding, covering how binding overrides work, UI integration, and saving and restoring settings.
01Unity's two main update functions: Update and FixedUpdate. Learn the critical differences in execution timing and when to use each for game logic versus physics—with practical examples.
02GetComponent is essential when you need to use another component's functionality. Learn everything from basic usage to retrieving components from child/parent objects and performance-conscious caching patterns.
03OnTriggerEnter and OnCollisionEnter both detect object contact. Learn when and how these event functions are called, their differences, and how to choose the right one for beginners.
04Need to wait a few seconds before resuming? Want to split heavy processing across frames? Learn Unity's powerful Coroutine feature with IEnumerator and yield return explained for beginners.
05When you need to write code that 'waits', should you reach for a coroutine or async/await? This guide untangles one of Unity's classic dilemmas: how the two mechanisms differ, when to use which, Unity 6's Awaitable, and the destroyed-object pitfall.
06Bugs are friends, not enemies! Learn Unity's most fundamental debugging technique, Debug.Log, how to read common error messages, and how to level up with breakpoint debugging.
07From the title screen to a stage, from a stage to the results screen. Learn the essentials of scene transitions—the backbone of your game's flow—with a beginner-friendly guide centered on the SceneManager class.
08Learn how to use DontDestroyOnLoad to keep objects alive across scene transitions, and how to manage them safely with the Singleton pattern.
09A beginner-friendly guide to Lerp (linear interpolation) and Slerp (spherical linear interpolation), the essential functions for smooth motion in Unity. Learn why objects slow down near the target (easing out) and when to use MoveTowards / RotateTowards for constant speed, with practical code examples.
10Learn the core concepts of Quaternions and how they differ from Euler angles. Covers how gimbal lock happens, the pitfalls of manipulating eulerAngles directly, and practical rotation control with LookRotation and Slerp, complete with code examples.
11Overusing GetComponent and direct references makes your code complex and fragile. Learn how to use C#'s powerful delegates and events to break dependencies between objects and design loosely coupled systems that are extensible and reusable.
12Attack detection, health, and invincibility frames are the first system almost every action game needs — and one of the easiest to break: one swing deals damage three times, death logic runs twice. Covers the Health / Hitbox / Hurtbox split, an attack window synced to the swing, once-per-swing hit management, and separating invincibility (rule) from damage flashing (visuals), all assembled in a small player-vs-enemy arena.
13How to implement the Singleton pattern correctly in Unity and what to watch out for. Covers building a reusable MonoSingleton base class, the pitfalls of execution order and duplicate instances, and guidelines for avoiding overuse.
14Escape nested if/switch hell. Learn how to use the classic object-oriented State Pattern to implement complex character states (idle, attack, defend, flee, and more) as a clean, highly extensible state machine.
15How do you manage the overall flow of your game? Learn the classic 'Game Manager' pattern for controlling game states (title, playing, game over) and centralizing critical data like scores and player status.
16GameManager, AudioManager, SaveManager — somewhere past your fifth manager, the classic swamp begins: "playing from the Game scene crashes with null," "it breaks or works depending on Awake order," "returning to the title duplicates the persistent objects." The answer is to assemble everything persistent exactly once, in a fixed order, in an initial Bootstrap scene. Explicit initialization order, a persistent-versus-content scene structure, and a safety net that makes any scene playable — we rebuild the foundation under your manager collection.
17You set Time.timeScale = 0 to pause the game, and now your menu animations froze too — a classic pause-implementation pitfall. This guide covers how timeScale works, exactly what stops and what doesn't, how to build UI that animates during pause, and where the timeScale approach reaches its limits.
18Jump fires repeatedly while the key is held, or Input.GetKey suddenly throws an exception after installing the Input System package—this guide solves the classic input-handling pitfalls. Covers when to use GetKeyDown/GetKey/GetKeyUp, how virtual axes work, the difference between GetAxis and GetAxisRaw, and when to migrate to the new Input System.
19Learn how to customize Unity's Inspector with C# attributes. Covers practical usage of SerializeField, Header, Range, RequireComponent, and more.
20Learn how to use Unity's Gizmos to visualize debug information in the Scene view. Display empty GameObjects, trigger areas, AI detection ranges, and more.
21How is automated testing different from eyeballing Debug.Log output? A beginner-friendly intro to Unity Test Framework covering Edit Mode vs. Play Mode tests, the AAA pattern, what Assembly Definitions really are, and a practical guide to what's actually worth testing in a game.
22You followed the tutorial exactly, yet the Console shows warnings — here's how to deal with deprecated APIs lurking in old articles and AI answers. A reference covering the Unity 6 migration table for FindObjectOfType, Rigidbody.velocity, and more, plus how to investigate any warning you encounter.
23Static events give you loose coupling, but they still depend on class names and their subscriptions survive scene reloads. Learn how the event channel pattern—turning events into ScriptableObject assets—takes your event design to the next level of flexibility and safety.
01A guide to Unity's three render pipelines (Built-in, URP, HDRP) and how to choose between them. Includes performance and feature comparisons, plus guidance on picking the best pipeline for your project.
02Learn how to create shaders in Unity without programming using Shader Graph. Customize materials intuitively with the node-based visual editor.
03Learn how to use post processing in Unity. Covers key effects like Bloom, Color Grading, and Depth of Field, with setup instructions for both the Built-in Render Pipeline and URP.
04Your attacks land, but the screen feels flat—what's missing is effects. This guide organizes Unity's built-in Particle System (Shuriken) modules around the 'life of a particle' and walks you through a hands-on recipe for building a hit effect.
05Paste one camera's footage onto UI or 3D objects — Render Texture is the entry point for minimaps, mirrors, security cameras, and portraits. Learn what a Render Texture is, the basic Camera → Render Texture → RawImage/Material setup, how to build a top-down minimap, and how to handle the per-frame rendering cost.
06Learn how to use Cinemachine, Unity's official camera control package. Achieve high-quality camera work—Virtual Cameras, camera shake, obstacle avoidance, and more—without writing scripts.
07You made the camera follow the player—and now the screen jitters and makes people motion-sick. That's the limit of hand-written follow scripts. Using Cinemachine's follow camera, this guide walks through hands-on tuning of the parameters that define camera feel: Dead Zone, Damping, and Lookahead.
08Your visuals are done, but the game somehow feels cheap when you play it — what's missing is sound. This guide covers the Audio Source/Listener basics, the standard patterns for BGM and sound effects (PlayOneShot), choosing between 2D and 3D sound with Spatial Blend, and setting up volume controls with the Audio Mixer.
09Looping the same BGM forever can't build tension. Use Audio Mixer snapshots to switch music by situation, ducking to lower the BGM only during dialogue, and crossfades to swap tracks seamlessly—the dynamic music control that raises a game's sense of polish, explained with implementation code.
10Your hit detection works and HP goes down, yet playing it feels like hitting a pillow — that's not a bug, it's missing game feel. Layer hit flash, particles, SFX, camera shake, and hit stop onto the same sword swing, build weak/strong/critical intensity presets, and use ON/OFF comparison to learn what information each effect carries. Also covers the classic accidents: every enemy flashing at once, a camera that never returns home, and a timeScale that never recovers.
01Your game stutters, but you can't tell what's slow — the golden rule of optimization is "Don't guess — measure." This guide covers the practical workflow for identifying spike culprits with the Profiler (CPU Usage, sorting by Self ms, the GC Alloc column) all the way to profiling on real devices.
02Frame rate is fine, yet the game dies suddenly on device; you leave a stage and memory never comes back — that's not a GC spike, it's resident memory. Covers taking snapshots with the Memory Profiler package, reading textures, meshes, and AudioClips in the Unity Objects view, the before/after comparison ritual that exposes what survives a scene unload, and thinking in per-device memory budgets — a straight road through investigating device crashes.
03Your game freezes for a split second every few seconds—more often than not, the culprit is garbage collection (GC). This article explains why GC causes stuttering, starting from how the stack and heap work, then covers concrete coding techniques that avoid generating garbage in the first place, plus Incremental GC.
04Your game stutters every time you fire a bullet—the culprit is repeated Instantiate and Destroy calls. Learn how object pooling reuses objects instead, covered both with a simple hand-rolled implementation and Unity's official ObjectPool<T> (UnityEngine.Pool).
05The more objects you place, the lower your frame rate drops — and the culprit is usually draw calls. This guide explains how CPU-to-GPU draw commands work and when to use each of the current reduction techniques: SRP Batcher, static batching, and GPU instancing.
06The bigger your 3D stage grows, the lower the frame rate falls — usually because you're faithfully rendering full-detail models in the far distance and entire neighborhoods hidden behind walls. Covers LOD Groups that swap models by distance, Occlusion Culling that skips what's blocked from view, and distance design with Far Clip and fog — three tools for not drawing the invisible, applied to lightening a city stage.
07Did you know that calling Update() has a cost all by itself? This article covers the Custom Update Manager, an advanced optimization that pays off when thousands of objects are moving — from how Update calls work (the native/managed bridge) to a full implementation.
08When the Profiler fingers thousands-to-tens-of-thousands of numeric computations — like distance checks against every enemy — GC and Update Manager optimizations stop being enough. Unity's Job System and the Burst compiler are the official way to hand independent bulk computation to worker threads. NativeArray handoffs and the Dispose responsibility, a minimal IJobParallelFor + Burst example, the correct Schedule → other work → Complete order, and knowing when plain C# is still the right call — all through the lens of computing distances for 10,000 enemies.
09Runs great on PC but stutters and overheats on real devices — mobile has constraints PC doesn't: heat and battery. This guide maps out mobile optimization through four pillars — rendering, CPU, memory, and mobile-specific concerns — and points you to detailed articles on each topic.
01Imported pixel art looks blurry, character sizes are all over the place—most early 2D stumbles come down to import settings. This guide covers Sprite setup, Pixels Per Unit, and Filter Mode, then moves on to slicing sprite sheets with the Sprite Editor and using Sprite Atlas.
02Your character tips over on its own, bullets pass through walls, you get stuck on slopes—every classic 2D physics problem has a standard fix. This article covers Rigidbody2D Body Types, choosing the right Collider2D, Is Trigger, and the go-to implementation idioms for 2D platformers.
03You've sliced your sprite sheet. Now how do you turn those frames into 'walking' and 'jumping'? This guide walks through the full pipeline for bringing a 2D character to life: creating clips in the Animation window, switching between them with an Animator Controller, and driving it all from a script.
04Build 2D game terrain efficiently with Tilemaps. Learn how Grid, Tilemap, and Tile Palette relate, how to add collision with Tilemap Collider 2D and Composite Collider 2D, how to split ground and decoration into layers, how to automate borders with Rule Tiles, and how to place tiles from scripts with SetTile.
05Lighting transforms the mood of a 2D game. Learn how to switch to URP's 2D Renderer, use the four Light 2D types (Global, Point, Freeform, Sprite), design with a dark Global Light plus a Point Light, cast shadows with Shadow Caster 2D, and build a player who carries a torch.
01Sinking into walls, tunneling through them, jittery movement—most classic physics headaches come down to understanding Rigidbody. This guide covers when to use transform vs Rigidbody, choosing between AddForce and linearVelocity, ForceMode, and Is Kinematic.
02The first step in 3D action is making a character feel good to walk. Learn when to use Rigidbody vs CharacterController, moving with Move(), ground checks with isGrounded, hand-rolling gravity and jumping, camera-relative movement, and climbing slopes and steps with Slope Limit and Step Offset — the standard walk/jump/climb implementation.
03What am I looking at? What did I click on? Am I standing on the ground? Physics.Raycast is the all-purpose tool for answering these spatial questions. This guide covers the basics, go-to recipes for click selection and ground checks, and the layer masks that trip up so many beginners.
04Your model imports gigantic, lies on its side, or turns pink — we solve the classic 3D model import headaches. Covers export pitfalls on the DCC side, the four import tabs (Model/Rig/Animation/Materials), and reusing animations with Humanoid rigs.
05The same sphere can look like gold, plastic, or rubber with a single setting change—that's the power of materials and shaders. This guide covers how the two relate, when to use Lit vs. Unlit, the three core PBR properties, a quick-reference table of material recipes, and the renderer.material pitfall.
06The exact same scene can feel like daytime, nighttime, or a horror setting depending on the lighting—nothing shapes the look of a 3D scene more than light. This guide covers the four light types and when to use each, the two pillars of realtime and baked lighting, Global Illumination, and the performance cost of shadows.
07Learn how to manage character animations with Unity's Animator Controller. Covers State Machines, Transitions, Parameters, and Blend Trees in detail.
08Moving smoothly in eight directions with WASD and attacking with just the upper body while running — the secret behind convincing 3D character movement is the combination of 2D Blend Trees, Avatar Masks, and Root Motion. This guide covers these 3D-specific techniques for developers who have moved past the Animator Controller basics.
09You can play animations. But 'deal damage exactly when the blade comes down,' 'make the lunge move the character as animated,' and 'plant the hand flat on the wall' are suddenly hard — they're synchronization problems between animation and the game world. Covers Animation Events that call code on specific frames, Root Motion that hands movement to the animation, and IK that snaps hands and feet onto targets — with use cases, pitfalls, working code, and a finished lunge attack.
10Your enemy walks straight at the player and gets stuck on a wall—the fix is NavMesh (pathfinding). From baking with NavMeshSurface to configuring the NavMesh Agent, chase AI with SetDestination, and the practical patrol-detect-chase-search pattern, this guide covers how to build smart enemies.
11As enemy AI grows complex, state machines explode with branches. Behavior Trees assemble behavior as a tree, making it reusable and extensible. Learn the basic nodes (Sequence, Selector, Condition, Action), Success/Failure/Running, when to use them vs state machines, the Unity 6 Behavior package, and building a patrol → spot → chase → attack enemy.
12Build the 'getting spotted' of a stealth game. Judge an enemy's field of view in three stages — distance, angle, and a Raycast occlusion check — to detect the player. From a view cone that misses players hiding behind walls, to state transitions on detection, to visualizing with Gizmos — the detection logic of stealth AI.
13Split one screen for two-player play — the foundation of local co-op and versus. Learn split-screen with multiple cameras' Viewport Rect, per-player input assignment with the New Input System's PlayerInputManager, and each player's own UI — the foundation of split-screen.
14Learn how to create vast natural environments with Unity's Terrain system. Covers terrain sculpting, texture painting, placing trees and grass, and performance optimization in detail.
01Your UI looked perfect in the editor, but falls apart on real devices or when the window is resized—the culprit is almost always anchors and the Canvas Scaler. This article covers uGUI's three core concepts (Canvas, RectTransform, Anchors), the go-to setup for handling different screen sizes (Scale With Screen Size), and a per-element anchor cheat sheet.
02You placed a button, but pressing it does nothing—the classic UI trap beginners hit first. This guide covers the two ways to register onClick, how a click reaches the button (EventSystem, Graphic Raycaster), the three top causes of an unresponsive button, adding press feedback with Transitions, and implementing a hold button.
03Still placing inventory slots one by one by hand? With Layout Groups (Horizontal/Vertical/Grid), you can leave UI alignment to Unity. This guide covers when to use each of the three, combining them with Content Size Fitter, common pitfalls, and a hands-on inventory grid built with a ScrollView.
04The moment you bring a working PC game to a phone, input and UI problems become personal. Covers tap, drag, and long-press detection with the New Input System's Enhanced Touch, two-finger pinch and pan, the standard guard that keeps UI touches from leaking into gameplay, and placing UI inside Screen.safeArea to dodge notches and punch-holes.
05Volume via AudioMixer, resolution via Screen, language via Localization, key rebinding via the Input System — you know each piece, yet the moment you build a settings screen, it collapses: scattered saves, settings that don't restore on launch, apply timing all over the place. This article unifies everything into one SettingsData, separates applying from saving, and finishes a SettingsManager that restores every setting at startup — linking out to the deep-dive articles for each field.
06You know uGUI. But when should you reach for UI Toolkit, the system whose star keeps rising in the Unity 6 era? The answer is coexistence, not replacement. Covers the UIDocument / UXML / USS division of labor, driving UI Builder screens from C#, switching visual states with USS classes, and ListView virtualization — all through building a quest log screen. And it's explicit about where uGUI remains the right tool.
07From setting up TextMeshPro to rich text features and performance optimization. Achieve high-quality text display.
08Build the conversation window of an RPG or visual novel with a minimal setup. Define lines with a ScriptableObject, add a typewriter effect that reveals text character by character with TextMeshPro, click to advance, and branch with choices — a dialogue engine that separates data from UI.
01PlayerPrefs is Unity's built-in feature for saving simple data like volume settings and high scores. Learn the basics of SetInt and GetInt, cases where you shouldn't use it, and why encryption matters.
02A save system that preserves player progress is essential for most games. Go beyond the limits of PlayerPrefs and learn how to save and load complex game data to files using JSON and Unity's JsonUtility class, with practical C# code examples.
03The most painful report a released game can get: 'my save data is gone.' Once you can save to JSON, the next step is making saves that don't break. Covers crash-proof writes via a temp file, the free one-generation backup you get from File.Replace, defensive loading with try-catch and value clamping, and saveVersion-based migration so player saves survive your game updates.
04Learn how to achieve data-driven design with ScriptableObjects, from core concepts to event system applications, with practical code examples.
05Build an RPG or survival inventory by separating data from UI. Define items with a ScriptableObject, design the slot data structure, handle add/remove/stack, reflect it in a grid UI, and save — the foundation of an extensible inventory system.
06You have dialogue, an inventory, and saving — yet the most ordinary fetch quest in all of RPGs, "collect 3 herbs and return to the villager," won't come together. What's missing is a home for progression state. Model quests with four states, separate master data from progress data, accept from a dialogue choice, update objectives from inventory changes, handle turn-in and rewards, and restore everything from a save — while plugging the classic holes: items collected before accepting, double rewards from button mashing, and saves that break when an asset gets renamed.
07Your game works fine with 'just throw it in the Resources folder' — so why does everyone say it's deprecated? Starting from how Unity loads assets into memory, this article covers the pros and cons of direct references, Resources, and Addressables, plus clear criteria for choosing between them.
08Learn how to use Addressables, Unity's official asset management system. It automates the complexities of AssetBundle management, making it easy to reduce build size and deliver downloadable content.
09"With Addressables you can ship content without an app update" — you believed it and made your assets Addressable, yet everything is still baked into the build. What's missing is the Remote setup. What Build Path and Load Path mean, the catalog that links your app to its content, the startup CheckForCatalogUpdates → UpdateCatalogs flow, and the update build that separates what may change from what must stay frozen. Using an event costume shipped after release as the example, we get post-launch content updates working end to end.
10Learn how to localize your game with Unity's official Localization package. Covers localizing text, images, and audio, plus dynamic text with Smart Strings.
01Building is the final hurdle between your finished game and your players. This guide covers the basics of Build Profiles (formerly Build Settings), the essential Player Settings, and the steps and pitfalls for PC, WebGL, Android, and iOS builds.
02Resolution and fullscreen toggles are must-have options for PC games. Learn how to change resolution at runtime with Screen.SetResolution, choose the right FullScreenMode, build a resolution dropdown from Screen.resolutions, and save the player's settings.
01Learn the fundamentals of online multiplayer with Unity's official Netcode for GameObjects. Covers the server authority mindset, syncing with NetworkObject/NetworkTransform, NetworkVariable, and RPCs — the core concepts to grasp first.
02Netcode for GameObjects syncs fine locally — but it won't connect to your friend's house. The wall is called NAT, and Unity's Relay and Lobby are the tools that climb it. Covers UGS initialization and anonymous sign-in, the host's Relay allocation and join code, client joining, a room your friend enters with a short code, heartbeats, and disconnect cleanup — the smallest online co-op session that actually reaches a friend.
