Unity Technical Notes

Learn 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.

What 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.

Learn 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.

C# 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.

Still 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.

You 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.

Prefabs 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.

File 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).

Graduate 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.

Learn to differentiate between Layers and Tags, control collision detection, and optimize Raycast with LayerMask for effective object management.

Learn how to use Unity's New Input System. Implement cross-platform input handling using Input Actions, Bindings, and the Player Input component.

You'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.

How 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.

Unity'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.

GetComponent 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.

OnTriggerEnter 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.

Need 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.

When 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.

Bugs 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.

From 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.

Learn how to use DontDestroyOnLoad to keep objects alive across scene transitions, and how to manage them safely with the Singleton pattern.

A 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.

Learn 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.

Overusing 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.

Attack 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.

How 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.

Escape 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.

How 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.

GameManager, 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.

You 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.

Jump 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.

Learn how to customize Unity's Inspector with C# attributes. Covers practical usage of SerializeField, Header, Range, RequireComponent, and more.

Learn how to use Unity's Gizmos to visualize debug information in the Scene view. Display empty GameObjects, trigger areas, AI detection ranges, and more.

How 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.

You 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.

Static 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.

Learn how to extend the Unity Editor to improve your development workflow. Covers MenuItem, EditorWindow, CustomEditor, PropertyDrawer, and more, with practical code examples for each type of editor extension.

Build an Inspector with CustomEditor, OnSceneGUI, and Handles that lets you grab and move an enemy's patrol route in the Scene view.

Learn how to manage character animations with Unity's Animator Controller. Covers State Machines, Transitions, Parameters, and Blend Trees in detail.

Moving 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.

You 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.

Learn how to use Unity Timeline to manage animations, audio, and camera movement along a timeline. Covers creating cutscenes and cinematic sequences, with a detailed look at Cinemachine integration.

A 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.

Learn how to create shaders in Unity without programming using Shader Graph. Customize materials intuitively with the node-based visual editor.

Learn 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.

Paste 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.

Learn 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.

You 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.

Your 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.

Learn how to use Unity's VFX Graph, a visual effect authoring tool that renders massive numbers of particles with high performance on the GPU. This guide covers the basic structure, how it differs from the classic Particle System, and practical usage.

Your 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.

Your 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.

Looping 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.

Your 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, Time ms and Self ms, the GC Alloc column) all the way to profiling on real devices.

Frame 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.

Your 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.

Your 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).

The 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.

The 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.

Did 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.

When 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.

Runs 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.

Imported 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.

Your 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.

You'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.

Build 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.

Lighting 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.

Sinking 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.

The 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.

What 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.

Your 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.

The 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.

The 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.

Split 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.

Learn 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.

Your 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.

As 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.

Build 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.

Your 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.

You 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.

Still 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.

The 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.

Volume 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.

You 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.

From setting up TextMeshPro to rich text features and performance optimization. Achieve high-quality text display.

Build 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.

PlayerPrefs 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.

A 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.

The 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.

Learn how to achieve data-driven design with ScriptableObjects, from core concepts to event system applications, with practical code examples.

Build 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.

You 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.

Your 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.

Learn 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.

"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.

Learn how to localize your game with Unity's official Localization package. Covers localizing text, images, and audio, plus dynamic text with Smart Strings.

Building 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.

Resolution 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.

Learn 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.

Netcode 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.