📝 Lesson 2.3: Instantiating and Destroying Objects

Prefabs: Reusable Templates

You can't spawn a GameObject from nothing at runtime — you spawn copies of a template. That template is a prefab.

You make one by dragging a configured GameObject from the Hierarchy into the Project window; it turns blue and becomes a reusable asset. The analogy to C# is exact:

💡 Prefab ≈ class, instance ≈ object. Just as new Enemy() creates an object from a class, Instantiate(enemyPrefab) creates a GameObject from a prefab. The difference: a prefab also carries all the scene data (meshes, components, tuned Inspector values) a plain class can't.

To spawn a prefab from a script, the script needs a reference to it — which is exactly the Inspector-wiring skill from Lesson 1.3: a [SerializeField] field you drag the prefab into.

Instantiate

Instantiate creates a copy of a prefab (or any object) in the scene. It has many overloads; these are the ones you'll use daily:

// 1) Copy at the prefab's own default position/rotation:
Instantiate(bulletPrefab);

// 2) Copy at a specific position and rotation (the most common form):
Instantiate(bulletPrefab, spawnPoint.position, spawnPoint.rotation);

// 3) Copy and immediately parent it under another Transform:
Instantiate(bulletPrefab, spawnPoint.position, spawnPoint.rotation, container);

The generic Instantiate<T>() — get a component directly

Plain Instantiate returns the type you passed in. When you spawn a prefab typed as a component, the generic overload returns that component directly, so you can configure it without a GetComponent call:

// If bulletPrefab is declared as a Bullet, this returns a Bullet — no cast, no GetComponent:
Bullet bullet = Instantiate(bulletPrefab, spawnPoint.position, spawnPoint.rotation);
bullet.speed = 20f;   // configure the fresh instance right away

⚠️ Important: The value Instantiate returns is your handle to the new object. If you don't capture it (var b = Instantiate(...)), you can't easily configure or track that instance afterward. Grab the return value whenever you need to touch the spawned object.

Configuring a Spawned Object

A spawned object usually needs setup the prefab can't know in advance — a bullet's direction, an enemy's target, a pickup's value. You do that right after instantiating, using the returned reference. Here's a spawner that fires bullets forward:

using UnityEngine;

public class Gun : MonoBehaviour
{
    [SerializeField] private Bullet bulletPrefab;   // drag the prefab here (Lesson 1.3)
    [SerializeField] private Transform muzzle;      // where bullets appear
    [SerializeField] private float bulletSpeed = 20f;

    void Update()
    {
        // Fire on the frame the key goes down (Lesson 1.2 / 2.1).
        if (Input.GetKeyDown(KeyCode.Space))
            Fire();
    }

    void Fire()
    {
        // Spawn at the muzzle, facing the muzzle's direction.
        Bullet bullet = Instantiate(bulletPrefab, muzzle.position, muzzle.rotation);

        // Configure the new instance: push it forward.
        bullet.Launch(muzzle.forward * bulletSpeed);
    }
}

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class Bullet : MonoBehaviour
{
    private Rigidbody body;

    void Awake() => body = GetComponent<Rigidbody>();

    public void Launch(Vector3 velocity)
    {
        body.linearVelocity = velocity;   // Unity 6 name (Lesson 2.2)
    }
}

Destroy: Cleaning Up

Every spawned object that isn't removed lives forever, piling up and eventually tanking performance. Destroy removes an object from the scene. You met it in Lesson 1.1; here are its important forms:

Destroy(gameObject);            // destroy the whole GameObject now (end of this frame)
Destroy(gameObject, 3f);        // destroy it after 3 seconds — great for timed cleanup
Destroy(this);                  // destroy just THIS component, leaving the GameObject
Destroy(GetComponent<Rigidbody>());   // remove one specific component

The timed overload is the idiomatic way to make short-lived objects clean up after themselves. A bullet that should vanish after 3 seconds does it in one line, in Start:

public class Bullet : MonoBehaviour
{
    [SerializeField] private float lifetime = 3f;

    void Start()
    {
        Destroy(gameObject, lifetime);   // self-cleanup — no manual bookkeeping
    }

    void OnCollisionEnter(Collision collision)
    {
        // Or destroy on impact, whichever comes first.
        Destroy(gameObject);
    }
}

💡 gameObject vs this: Destroy(gameObject) removes the entire object and everything on it; Destroy(this) removes only the script component. Ninety percent of the time you want Destroy(gameObject) — a common bug is destroying just the component and wondering why the object is still there.

The Spawn/Destroy Lifecycle

A runtime-created object runs the same lifecycle you learned in Lesson 1.2 — it just begins mid-game instead of at scene load. When you Instantiate, Unity immediately runs the new object's Awake and OnEnable; its Start fires just before its first Update. When destroyed, OnDisable then OnDestroy run.

This is why bullet setup goes in Awake/Start and cleanup (like unsubscribing) goes in OnDestroy — exactly the rules from Module 1, now applied to objects born at runtime. There's nothing new to learn about the lifecycle; spawning just triggers it on demand.

Why Pooling Exists

Instantiate and Destroy aren't free. Creating an object allocates memory and runs its Awake/Start; destroying it produces garbage that the C# garbage collector must later clean up. Do this a few times and no one notices. Do it hundreds of times per second — a bullet-hell shooter, a particle-heavy effect — and you get frame hitches from GC spikes.

The fix is object pooling: instead of destroying an object, you deactivate it and stash it; next time you'd spawn, you reactivate one from the pool. No allocation, no garbage. It's the single most important optimization for spawn-heavy games.

Exercise & Quiz

using UnityEngine;

public class Gun : MonoBehaviour
{
    [SerializeField] private Bullet bulletPrefab;
    [SerializeField] private Transform muzzle;
    [SerializeField] private float bulletSpeed = 20f;

    void Update()
    {
        // TODO: on Space, spawn a bullet at the muzzle and launch it forward.
    }
}

using UnityEngine;

public class Gun : MonoBehaviour
{
    [SerializeField] private Bullet bulletPrefab;
    [SerializeField] private Transform muzzle;
    [SerializeField] private float bulletSpeed = 20f;

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
            Fire();
    }

    void Fire()
    {
        Bullet bullet = Instantiate(bulletPrefab, muzzle.position, muzzle.rotation);
        bullet.Launch(muzzle.forward * bulletSpeed);
    }
}

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class Bullet : MonoBehaviour
{
    [SerializeField] private float lifetime = 3f;
    private Rigidbody body;

    void Awake() => body = GetComponent<Rigidbody>();

    void Start()
    {
        Destroy(gameObject, lifetime);   // self-cleanup
    }

    public void Launch(Vector3 velocity)
    {
        body.linearVelocity = velocity;
    }
}

Summary

📚 Additional Resources

• Scripting Reference — Object.Instantiate
• Scripting Reference — Object.Destroy
• Manual — Prefabs
• Scripting Reference — ObjectPool (preview of Lesson 5.1)

🚀 What's Next?

That wraps Module 2 — Gameplay Scripting: things move, collide, spawn, and disappear. Module 3 turns to structure. Lesson 3.1, ScriptableObjects for Data, shows a cleaner way to hold shared data (like bullet stats) as assets — no MonoBehaviour required.