Creating a 2D Platformer in Unity: The Beginning

By the end of this tutorial, you will have a small, testable 2D platformer prototype in Unity 6.x: a placeholder player that can run left and right, jump only while grounded, land on platforms, and remain visible as the camera follows it.

This is deliberately not a complete game. There will be no enemies, combat, collectibles, menus, save system, or polished art yet. The first milestone is proving that the core loop works. The instructions and code below target Unity 6.1, documented by Unity as internal version 6000.1. Inspector labels, package versions, and menu locations can change in later releases.

#	Preview	Product	Price
1		Learning C# by Developing Games with Unity 6: Get to grips with coding in C# and build simple 3D...	$35.99	Buy on Amazon
2		Advanced Unity 6 Game Development with C#: Build 2D and 3D Games with Scalable Architecture,...	$26.00	Buy on Amazon
3		Unity in Action, Third Edition: Multiplatform game development in C#	$40.00	Buy on Amazon
4		Unity All-In-One: A Handbook to Build 3D Games from Start to Finish and Learn C# in the Process	$2.99	Buy on Amazon
5		Unity from Zero to Proficiency (Beginner): A Step-by-step guide to coding your first game	$26.59	Buy on Amazon

As an Amazon Associate I earn from qualifying purchases.

What you are building

A platformer is a genre rather than one fixed technical template. A physics-driven platformer, precision platformer, auto-runner, and character-controller-heavy game may all require different movement systems.

This beginning uses the simplest useful target:

• A side-view level
• One player character
• Keyboard left/right movement
• Grounded jumping
• Static platforms
• An orthographic follow camera

Unity is a suitable choice for this prototype because its 2D workflow includes sprites, Tilemaps, SpriteShape, 2D physics, animation, and related tools. Unity’s 2D workflow documentation specifically covers the systems commonly used for side-on platformers.

#1 Best Overall

Sale

Learning C# by Developing Games with Unity 6: Get to grips with coding in C# and build simple 3D games in Unity from the ground up

$35.99

Buy on Amazon

What you need before starting

• Unity Hub
• A current Unity 6.x editor. This article uses Unity 6.1 / 6000.1.
• A C# editor such as Visual Studio or another editor supported by Unity.
• Basic familiarity with files, folders, and keyboard input.
• Optional version control. Unity’s version-control guidance is worth considering once the project contains scripts and scenes you cannot easily recreate.

Use the same editor version as the tutorial where possible. Older tutorials often use the legacy Input Manager, older Rigidbody2D property names, or different package workflows.

Do you need to pay for Unity?

For a beginner or eligible small team, Unity Personal is the natural starting point. Unity’s current plan information says Personal is available to individuals and small organizations below its stated revenue and funding threshold. Check the official eligibility page before publishing a commercial project, because thresholds, regions, taxes, and plan terms can change.

Unity Pro is not necessary for this prototype. Unity currently lists Pro at $210 per month or $2,310 per year in the United States before applicable regional adjustments, but the plan is intended for professional use and has separate requirements. A Unity subscription alone also does not grant access to closed-console platforms; platform-holder approval and additional requirements apply.

Create the 2D project

1. Open Unity Hub.
2. Install the chosen Unity 6.x editor.
3. Choose New project.
4. Select the 2D template.
5. Name the project PlatformerPrototype.
6. Choose a location and create the project.
7. Save the initial scene immediately with File > Save As.
8. Create a scene named Level_01.

The 2D template includes many of the packages used for 2D development. Unity’s 2D setup documentation describes the template and related systems, including Tilemap and 2D animation tools.

Organize the project

In the Project window, create this structure:

Assets/
  Art/
    Characters/
    Environment/
  Audio/
  Materials/
  Prefabs/
  Scenes/
  Scripts/
    Player/
    World/
  Tilemaps/
  UI/

Save scenes with descriptive names, create a Player prefab once the initial GameObject works, and keep scripts focused. Input, movement, animation, health, combat, and camera control should not become one giant controller file.

Build a temporary level first

Use plain shapes or a temporary sprite. Do not begin by importing a polished character sheet or buying an art pack. Art import settings, animation frames, sorting layers, and asset licenses can distract from the systems that need testing.

Rank #2

Advanced Unity 6 Game Development with C#: Build 2D and 3D Games with Scalable Architecture, Performance Optimization, and Professional Gameplay ... Unity 6 Professional Game Programming Series)

$26.00

Buy on Amazon

Make a floor

1. Create a new empty GameObject and name it Ground.
2. Add a SpriteRenderer, or use a simple visible placeholder.
3. Add a BoxCollider2D.
4. Create a layer named Ground and assign the object to it.
5. Duplicate the object several times to make ledges and steps.

For the first test, individual Sprite GameObjects are easier than a Tilemap: each platform has an obvious collider and can be inspected separately. Later, use a Grid and Tilemap for larger, reusable levels.

Create the player

1. Create a visible placeholder sprite or simple square and name it Player.
2. Add a Rigidbody2D.
3. Add a CapsuleCollider2D or narrow BoxCollider2D.
4. Set the Rigidbody2D body type to Dynamic.
5. Freeze rotation on the Z axis under Constraints.
6. Leave mass and drag near their defaults until movement works.
7. Place the player above the floor.

Each component has a different responsibility:

• Transform: position, rotation, and scale.
• Rigidbody2D: participation in Unity’s 2D physics simulation, including gravity and velocity.
• Collider2D: the shape used for collision.
• SpriteRenderer: the visible image.
• Animator: later, idle, run, jump, and fall animation states.
• Script: input, movement decisions, and grounded state.

Do not move a physics-controlled player by repeatedly assigning transform.position. Unity’s Rigidbody2D documentation explains why physics objects should be moved through their Rigidbody2D. Mixing Transform movement with Rigidbody2D movement can cause tunneling, jitter, and unreliable collision results.

Choose the collider carefully

A CapsuleCollider2D is forgiving around corners; a BoxCollider2D is easy to inspect. Avoid a detailed PolygonCollider2D for a simple character unless the artwork genuinely requires it.

Check that the collider does not extend noticeably below the feet, is not wider than the sprite, and is not accidentally attached to the wrong object. A character collider that is too large can create invisible wall collisions or make the player appear to float.

Add keyboard controls with the Input System

The recommended approach is Unity’s Input System rather than legacy calls such as Input.GetAxis. Unity’s official Player character and movement course uses the Input System and frame-rate-independent 2D movement.

Create the actions

1. In the Project window, choose Create > Input Actions.
2. Name the asset PlayerControls.
3. Open it.
4. Create an action map named Player.
5. Create a Move action with type Value and control type Vector2.
6. Add keyboard bindings for A/D and/or the Left/Right arrow keys.
7. Create a Jump action with type Button.
8. Bind Jump to Space.
9. Save the asset.

Add a PlayerInput component to the Player and assign the Input Actions asset. If you use the callback approach below, set the component’s behavior to the callback mode expected by your Unity version, commonly Send Messages. The callback method names must match the action names: OnMove and OnJump.

Rank #3

Sale

Unity in Action, Third Edition: Multiplatform game development in C#

$40.00

Buy on Amazon

Two timing rules matter:

• Update follows rendered frames and is a good place to read short-lived input events.
• FixedUpdate follows the physics timestep and is the appropriate place to change physics movement.

Reading only in FixedUpdate can miss a short button press. Applying physics movement only in Update can produce inconsistent results as rendering and physics run at different rates. The script below stores input in fields, reads callbacks as they arrive, and changes Rigidbody2D velocity in FixedUpdate.

Write the first movement script

Create Assets/Scripts/Player/PlayerController.cs and attach it to the Player:

using UnityEngine;
using UnityEngine.InputSystem;

public class PlayerController : MonoBehaviour
{
    [SerializeField] private float moveSpeed = 6f;
    [SerializeField] private float jumpSpeed = 12f;
    [SerializeField] private Transform groundCheck;
    [SerializeField] private float groundCheckRadius = 0.15f;
    [SerializeField] private LayerMask groundLayer;

    private Rigidbody2D body;
    private Vector2 moveInput;
    private bool jumpRequested;

    private void Awake()
    {
        body = GetComponent<Rigidbody2D>();
    }

    public void OnMove(InputAction.CallbackContext context)
    {
        moveInput = context.ReadValue<Vector2>();
    }

    public void OnJump(InputAction.CallbackContext context)
    {
        if (context.performed)
            jumpRequested = true;
    }

    private void FixedUpdate()
    {
        body.linearVelocity = new Vector2(
            moveInput.x * moveSpeed,
            body.linearVelocity.y
        );

        if (jumpRequested && IsGrounded())
        {
            body.linearVelocity = new Vector2(
                body.linearVelocity.x,
                jumpSpeed
            );
        }

        jumpRequested = false;
    }

    private bool IsGrounded()
    {
        return Physics2D.OverlapCircle(
            groundCheck.position,
            groundCheckRadius,
            groundLayer
        );
    }

    private void OnDrawGizmosSelected()
    {
        if (groundCheck == null)
            return;

        Gizmos.color = Color.yellow;
        Gizmos.DrawWireSphere(
            groundCheck.position,
            groundCheckRadius
        );
    }
}

This example uses Rigidbody2D.linearVelocity, the relevant property name for the Unity 6.1 API targeted here. Older tutorials commonly use Rigidbody2D.velocity. Do not silently mix code from different Unity versions; if your editor reports that linearVelocity is unavailable, check the exact editor and API documentation rather than guessing.

Directly controlling horizontal velocity makes the first prototype easy to tune while gravity controls the vertical component. It is not automatically the best movement model for every platformer. A polished precision controller may eventually use acceleration, custom collision handling, coyote time, jump buffering, and slope rules.

Add reliable ground detection

1. Right-click the Player in the Hierarchy and choose Create Empty Child.
2. Name the child GroundCheck.
3. Move it just below the player’s feet.
4. Drag it into the script’s Ground Check field.
5. Set the player’s Ground Layer field to the Ground layer.
6. Set the radius to a small value such as 0.15.

The overlap circle must be large enough to detect the floor but small enough not to detect nearby walls or platforms. A check placed inside the player collider, or a layer mask set to Nothing, can make the result confusing. The yellow gizmo appears when the Player is selected, letting you inspect the check area in the Scene view.

This grounded check prevents infinite midair jumping. It also makes the architecture visible: the player has a defined sensor, a defined ground layer, and a condition that must be true before jumping.

Rank #4

Sale

Unity All-In-One: A Handbook to Build 3D Games from Start to Finish and Learn C# in the Process

$2.99

Buy on Amazon

Use Tilemaps when the level grows

Once the individual-platform prototype works, create a scalable level workflow:

1. Create a Grid.
2. Add a Tilemap beneath it.
3. Open the Tile Palette.
4. Prepare tile assets from your environment artwork.
5. Paint the platforms.
6. Add a TilemapCollider2D.
7. Assign the Tilemap to the Ground layer.

A CompositeCollider2D can be useful where appropriate to combine collider geometry, but it is not required for the first test. Tilemaps introduce additional concepts—Grid, Tile Palette, tile assets, collider generation, and sorting—so they are better learned after the player can already run and jump. Unity describes Tilemap in its 2D game-creation workflow.

One-way platforms and slopes should wait. One-way platforms involve Platform Effector 2D, dropping through behavior, and edge cases involving collider thickness and downward speed. Slopes require surface normals, slope limits, and special handling to prevent sliding or false airborne states.

Add a simple camera

Select the Main Camera and set its projection to Orthographic. Keep its Z position behind the 2D scene. For a very small prototype, parenting the camera to the player works, but it also copies every vertical movement and makes later room transitions awkward.

A small follow script provides more control. Create Assets/Scripts/World/CameraFollow.cs:

using UnityEngine;

public class CameraFollow : MonoBehaviour
{
    [SerializeField] private Transform target;
    [SerializeField] private float smoothTime = 0.1f;

    private Vector3 velocity;

    private void LateUpdate()
    {
        if (target == null)
            return;

        Vector3 targetPosition = new Vector3(
            target.position.x,
            target.position.y,
            transform.position.z
        );

        transform.position = Vector3.SmoothDamp(
            transform.position,
            targetPosition,
            ref velocity,
            smoothTime
        );
    }
}

Attach it to the camera and drag the Player into its Target field. LateUpdate lets the camera follow after the player’s movement for the frame has been processed.

Best Value

Sale

Unity from Zero to Proficiency (Beginner): A Step-by-step guide to coding your first game

$26.59

Buy on Amazon

A production platformer usually needs camera bounds, look-ahead, dead zones, room transitions, and limits that prevent the camera from showing outside the level. Those are later improvements, not requirements for this milestone.

Add animation only after movement works

Use the placeholder until the physics and input loop is reliable. Then:

1. Import a sprite sheet.
2. Create animation clips for Idle, Run, Jump, and Fall.
3. Create an Animator state machine.
4. Drive transitions with horizontal speed, vertical speed, and grounded state.
5. Flip the SpriteRenderer horizontally when changing direction instead of making separate left/right clips where appropriate.

Unity’s current manual documents animation clips and Animator state machines. Animation should display the movement system, not hide a movement system that has not been debugged.

Test the milestone

Press Play and verify each result separately:

1. Press left and right. The player moves horizontally.
2. Release the keys. Horizontal movement stops according to the controller’s direct-velocity model.
3. Gravity pulls the player down.
4. The player lands on the floor and platforms.
5. Jump works while grounded.
6. Jump does not work repeatedly in midair.
7. The player does not rotate.
8. The camera keeps the player visible.
9. The Console contains no repeated errors.

Troubleshooting

Physics choices to understand early

Rigidbody2D versus a custom controller

Rigidbody2D is the right starting point here because it gives a beginner gravity, collision, and a playable result quickly. Its trade-off is that default physics can feel slippery and may require careful treatment of slopes, walls, and moving platforms.

A custom kinematic controller can provide more deterministic acceleration, jump height, coyote time, and collision response, but it requires more code and introduces more edge cases. It is often appropriate for a precision platformer, not necessarily for the first lesson.

Velocity versus forces

Direct velocity is straightforward to tune. Forces are more physically expressive, but repeatedly applying force without a speed cap can create runaway acceleration and floaty controls. Platformers generally prioritize intentional controls over physical realism.

Rigidbody2D settings

• Body Type: Dynamic is the usual choice for this physics-based player.
• Gravity Scale: controls how strongly gravity affects the player.
• Constraints: freeze Z rotation.
• Collision Detection: continuous detection may help fast-moving objects, but it is not a universal fix.
• Interpolate: can smooth visual motion when appropriate.
• Mass and drag: leave near defaults until the basic controller is working.

What belongs in the next part

After this prototype is stable, build outward in this order:

• Better movement feel, including acceleration and deceleration
• Coyote time and jump buffering
• Sprite sheets and Animator parameters
• Tilemap-based levels
• One-way platforms and slopes
• Hazards, enemies, and damage
• Checkpoints and respawning
• Audio, UI, menus, and scene transitions
• Build settings and deployment

The Unity Learn Player character and movement course is a useful structured follow-up for readers who want more guided practice with 2D control and the Input System.

Quick Recap

SaleBestseller No. 1

Learning C# by Developing Games with Unity 6: Get to grips with coding in C# and build simple 3D games in Unity from the ground up

$35.99

Bestseller No. 2

Advanced Unity 6 Game Development with C#: Build 2D and 3D Games with Scalable Architecture, Performance Optimization, and Professional Gameplay ... Unity 6 Professional Game Programming Series)

$26.00

SaleBestseller No. 3

Unity in Action, Third Edition: Multiplatform game development in C#

$40.00

SaleBestseller No. 4

Unity All-In-One: A Handbook to Build 3D Games from Start to Finish and Learn C# in the Process

$2.99

SaleBestseller No. 5

Unity from Zero to Proficiency (Beginner): A Step-by-step guide to coding your first game

$26.59

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.