The Transform

The Transform is the only component every GameObject is guaranteed to have. It answers three questions: where the object is, which way it faces, and how big it is. It also defines the parent-child hierarchy you see in the Hierarchy window.

Local space and world space

This is the single most common source of "why is my object in the wrong place" confusion. Every transform has two sets of coordinates.

Moving things

There are three common ways to move a transform, and they are not interchangeable.

using UnityEngine;

public class MoveExamples : MonoBehaviour
{
    [SerializeField] private float speed = 5f;

    private void Update()
    {
        // 1. Teleport - set the position outright
        transform.position = new Vector3(0f, 1f, 0f);

        // 2. Offset - add to the current position
        transform.Translate(Vector3.forward * speed * Time.deltaTime);

        // 3. Interpolate - ease toward a target
        transform.position = Vector3.MoveTowards(
            transform.position,
            target.position,
            speed * Time.deltaTime
        );
    }
}

// Wrong - will not compile
// transform.position.x = 5f;

// Right - replace the whole vector
Vector3 p = transform.position;
p.x = 5f;
transform.position = p;

Always multiply by Time.deltaTime

Update runs once per rendered frame, and frame rate varies between machines and moments. If you move by a fixed amount per frame, your game runs faster on a faster computer — which is a real bug, not a curiosity.

private void Update()
{
    // 5 units per SECOND, on every machine
    transform.Translate(Vector3.forward * 5f * Time.deltaTime);
}

private void Update()
{
    // 5 units per FRAME.
    // 300 units/sec at 60fps, 750 units/sec at 150fps.
    transform.Translate(Vector3.forward * 5f);
}

Rotation, and why Quaternions

transform.rotation is a Quaternion, not the three angles you see in the Inspector. Quaternions avoid gimbal lock and interpolate cleanly, but they are not human-readable — you should essentially never set their x, y, z, w by hand.

// Build a rotation from readable angles
transform.rotation = Quaternion.Euler(0f, 90f, 0f);

// Turn a little each frame
transform.Rotate(0f, 90f * Time.deltaTime, 0f);

// Face a target
Vector3 direction = target.position - transform.position;
transform.rotation = Quaternion.LookRotation(direction);

// Ease toward a target rotation
transform.rotation = Quaternion.Slerp(
    transform.rotation,
    targetRotation,
    5f * Time.deltaTime
);

Direction vectors

Every transform exposes its own axes, which is almost always what you want for movement relative to where something is facing.

Parenting

Making one transform a child of another means it inherits position, rotation, and scale. Move the parent and the children come along.

// Attach to a parent, keeping the current world position
weapon.transform.SetParent(hand, worldPositionStays: true);

// Attach and snap to the parent's local origin instead
weapon.transform.SetParent(hand, false);
weapon.transform.localPosition = Vector3.zero;

// Detach
weapon.transform.SetParent(null);

Two traps worth knowing early

What to take away

• The Inspector shows local values; transform.position is world.
• Multiply every per-frame movement by Time.deltaTime.
• You cannot assign to transform.position.x — replace the whole vector.
• Build rotations with Quaternion.Euler or LookRotation, never by hand.
• transform.forward is object-relative; Vector3.forward is world-fixed.
• Keep scale uniform on anything with a collider.