Unity Technical Notes

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.