How to Make a Platformer in Game Maker (Free AI Sprites)

There is a recognizable shape to the search query how to make a platformer in Game Maker: an indie dev picked Game Maker because it is the lowest-friction commercial 2D engine on the market (one-time $99.99 for a full commercial license, no royalties, no subscription if you skip console export), they have walked through one or two beginner tutorials, and they want the next thing every platformer needs — gravity that accumulates, a jump that arcs, ground that stops the fall, and sprites that look like a real game instead of a placeholder grey rectangle. The honest answer comes in two halves. The first half is pure GML: a tiny Step-event script using four variables (move_speed, jump_speed, move_x, move_y), a place_meeting ground check, and Game Maker’s modern move_and_collide physics call. The second half is the asset side that Game Maker leaves open: AI-generated hero sprites with proper four-direction walk cycles, a real pixel palette instead of stock pack art, and a music loop that does not come from the same CC0 chiptune folder everyone else uses. Below is the full pipeline (verified 2026-06-08 against the Game Maker official Easy Platformer tutorial and the Sorceress source code) that turns the empty Game Maker project into a playable platformer.

What “How to Make a Platformer in Game Maker” Means in 2026

Before the code, the terms. Game Maker (originally Animo, later Game Maker, then GameMaker Studio, now simply GameMaker) is a 2D game engine first released in 1999 by Mark Overmars, sold to YoYo Games in 2007, and acquired by Opera Limited in 2021. The engine ships a packaged IDE with a built-in Sprite Editor, Room Editor, Object Editor, Tile Set Editor, and GML (Game Maker Language) code editor; it targets every desktop, mobile, console, and HTML5 web platform from a single codebase. A platformer is the side-view genre defined by a character that jumps from platform to platform while gravity pulls it back to the ground — the side-view tradition that runs from Donkey Kong through Super Mario Bros. through Sonic the Hedgehog through Celeste and Hollow Knight (Hollow Knight itself was built in the same engine you are about to use). The platformer-in-Game-Maker search slot covers the intersection: how to make a platformer in Game Maker that actually feels like a real platformer (gravity, jump, ground collision, sprite facing, walk cycle) instead of a static grey rectangle that teleports up when the space key is pressed.

Two things separate a beginner Game Maker platformer from one that feels right. The first is the physics: gravity must accumulate over time, jumps must arc instead of snap, ground detection must fire before the sprite renders at its new y position, and sprite facing must flip with horizontal input. The second is the art: Game Maker’s Free tier ships with no asset pack at all (just the IDE), so a Game Maker platformer with a proper hero sprite (recognizable silhouette, four-frame walk cycle that loops, palette-locked colours that read clearly against the background) feels eight steps closer to a real game with no extra GML code. The pipeline below covers both halves.

The Five Pieces Every Game Maker Platformer Needs

One IDE, five AI helpers, zero ongoing subscription cost.

• Game Maker (Free tier) — the IDE itself, free for non-commercial use, with exports to Desktop (Windows, macOS, Linux), Mobile (Android, iOS, tvOS), HTML5 Web, and Game Maker’s own GX.games web platform. The Free tier is the same IDE as the paid tiers with no asset count limits and no watermark; the only restrictions are that you cannot sell the game commercially (one-time $99.99 Professional license unlocks that) and you cannot export to Xbox, PlayStation, or Switch (Enterprise subscription at $79.99 per month or $799.99 per year unlocks console). Verified against the Game Maker pricing page on 2026-06-08.
• Sorceress AI Image Gen at /generate — type a one-sentence prompt for the hero character (style, palette, pose, view angle), pick a 1:1 aspect ratio at 1024 by 1024, and let the model render a clean side-view reference. This is the source image that the next two tools convert into a Game-Maker-ready PNG sprite.
• Sorceress True Pixel at /pixel-art — the browser pixelizer that takes the AI-rendered character and converts it to a real pixel-art sprite locked to one of eight retro palettes (PICO-8 16, SWEETIE-16, Endesga 32, Game Boy, CGA, NES 54, Grayscale 8, 1-Bit; verified against src/app/pixel-art/page.tsx on 2026-06-08). True Pixel handles the downscale, the edge cleanup, and the optional dithering pass; it outputs a transparent-background PNG that drops straight into Game Maker’s Sprite Editor Import command.
• Sorceress Quick Sprites at /quick-sprites — the walk-cycle generator that takes the pixelized hero and produces a four-direction four-frame walking animation on a 48-by-48 grid (Four Angle Walking style) or a six-row Small Sprites sheet at 32 by 32 (right, left, arms, look, surprise, lay down). Each generation runs the Retro Diffusion rd-animation model at nine credits per generation, verified against src/app/quick-sprites/page.tsx lines 18 through 48 on 2026-06-08. The output is a sprite-sheet PNG you load straight into Game Maker via Image, Import Strip Image with frame count 16, frame width 48, frame height 48, frames per row 4.
• Sorceress Music Gen at /music-gen plus Sound Studio at /sound-creator and SFX Gen at /sfx-gen — three browser tools that handle the audio half of a Game Maker platformer: Music Gen produces a looping level track from a text prompt (10 credits per generation per src/app/music-gen/page.tsx line 26), SFX Gen produces short SFX clips (jump, land, hit, coin), Sound Studio trims and masters the results. Game Maker accepts WAV, MP3, and OGG audio assets — all three Sorceress audio tools export to those formats.

The full Sorceress stack starts at the free signup tier (100 starter credits, verified against the Sorceress home hero on 2026-06-08), which covers roughly the first complete art-and-audio pass for one Game Maker platformer level. After the starter credits, the credit packs at $10 for 1,000 credits never expire and never auto-renew — a hard-stop credit model that suits the one-project-at-a-time rhythm of a Game Maker hobby project. Lifetime access to all the non-credit tools (True Pixel, Auto-Sprite v2, 3D Studio, Procedural Walk, Tileset Forge, Canvas, the Sprite Analyzer + Slicer, and more) is $49 one-time, also verified against src/app/plans/page.tsx line 44 on 2026-06-08.

Step 1 — Set Up the Game Maker Project (Free Tier, IDE, First Sprite)

Download Game Maker from the official site, sign in with the free account, and launch the IDE. From the Game Maker landing screen, click New Project, give it a name (something like platformer-test), and pick GML Code as the project language (not GML Visual unless you specifically want the drag-and-drop block editor; GML Code is the standard scripting language and matches every tutorial in the Game Maker documentation). The IDE opens with the Asset Browser on the right, an empty Code Editor in the center, and an empty Room Editor on the left.

Create the three asset types every platformer needs before you write a single line of code:

1. Sprites. Right-click the Sprites folder in the Asset Browser, pick Create Sprite, and name it spr_player. Double-click to open the Sprite Editor. For now, draw a placeholder rectangle in the editor canvas (we will replace this in Step 2). Set the sprite origin to Middle Centre via the Origin dropdown at the top of the Sprite Editor (so the sprite rotates and flips around its center pixel, which makes the platformer math cleaner). Create a second sprite called spr_ground the same way and draw a horizontal rectangle — this is the floor and platform tile.
2. Objects. Right-click the Objects folder, Create Object, name it obj_player, and assign spr_player as its sprite. Create a second object obj_ground and assign spr_ground. Tick the Solid checkbox on obj_ground — this flags it as a collision target for the physics call we will write in Step 3.
3. Room. Right-click the Rooms folder, Create Room, and name it rm_level_1. Double-click to open the Room Editor. Drag a single obj_player instance into the upper-left of the room and drag a horizontal row of obj_ground instances across the bottom of the room (this is the floor). Game Maker uses a 32-pixel grid by default, which works fine for a 48-by-48 player sprite.

Turn off pixel-interpolation so the AI-generated sprites stay crisp at every zoom: open Game Options (the Tools menu, then Game Options), navigate to the Graphics section, and untick Interpolate colors between pixels. Save the project. The IDE is now ready for sprites and code.

Step 2 — Generate the Player Sprite (Free AI Sprites From Sorceress)

Open /generate in a new browser tab. In the prompt box, describe the hero character in one sentence: appearance, palette mood, view angle, action stance. Two prompts that consistently work for platformer heroes:

• “Side-view pixel-art knight character, blue armor, red plume, sword at side, idle stance, transparent background, NES-style palette, 1024 by 1024 square format.”
• “Side-view chibi adventurer, lavender cloak, brown boots, idle stance, transparent background, retro pixel-art aesthetic, 1024 by 1024 square.”

Pick a 1:1 aspect ratio (Game Maker sprites render best as squares because the Sprite Editor’s frame-grid math is built around uniform-aspect frames). Generate; the model returns a clean illustration. Save the chosen PNG.

Open /pixel-art in another tab. Drag the saved PNG into the True Pixel upload zone. The tool reads the image, downscales it to a pixel grid (default 48 by 48, which matches the Quick Sprites Four Angle Walking grid we will use next), and asks you to pick a palette. The choice matters: a 16-colour PICO-8 palette reads cleanly on a Game Maker room at any scale, a 32-colour Endesga 32 palette gives more painterly depth, and the Game Boy four-colour palette produces the classic monochrome look. Pick one, preview the result, optionally enable the dithering pass to smooth gradients, and export the final PNG. The output is a transparent-background sprite locked to the chosen palette at 48 by 48 pixels.

Now open /quick-sprites. Drag the True Pixel hero PNG into the upload zone. Pick the animation style: Four Angle Walking produces a 48-by-48 pixel grid with four frames of walking animation in each of four directions (up, right, down, left), which is the right choice for a top-down or three-quarter-view platformer. For a strict side-view platformer, the Small Sprites style at 32 by 32 with six rows (right, left, arms, look, surprise, lay down) is often closer to what you want. Pick the style that matches your game’s camera angle. Quick Sprites runs the Retro Diffusion rd-animation model at nine credits per generation; the output is a single sprite-sheet PNG with every frame laid out on a grid. For Four Angle Walking that is a 192-by-192 sheet (four columns of 48-by-48 frames in four rows, 16 frames total). Download the sheet.

Back in Game Maker, double-click spr_player in the Asset Browser to open the Sprite Editor. From the Image menu, pick Import Strip Image, navigate to the Quick Sprites PNG, and click Open. Game Maker asks four numbers in the import dialog:

• Number of Frames: 16 (four directions of four frames each).
• Frame Width: 48.
• Frame Height: 48.
• Frames Per Row: 4.

Game Maker auto-slices the sheet into 16 sequential frames and lines them up in the Sprite Editor timeline. Confirm the origin is still Middle Centre and save the sprite. End-to-end time from AI Image Gen prompt to Game Maker import is about ten minutes the first run, four minutes once you have the rhythm. Credit cost is about three credits for the AI Image Gen render, one credit for the True Pixel pass, and nine credits for the Quick Sprites sheet — thirteen of the 100 starter credits per hero variant, which is cheap enough to roll three or four candidates and pick the strongest one.

Step 3 — Write the GML Platformer Code (Movement, Gravity, Jump)

This is the heart of the answer to how to make a platformer in Game Maker. The same code pattern shows up in roughly every well-built Game Maker platformer because it is the smallest set of variables and event blocks that produces convincing 2D game physics on the Game Maker stage. The pattern is documented in Game Maker’s official Easy Platformer tutorial; the version below is verified against that tutorial on 2026-06-08.

Open obj_player in the Object Editor. Add a Create Event via the Add Event dropdown, pick Create, then paste this GML into the code editor that opens:

// Create Event - obj_player
move_speed = 4;
jump_speed = 16;
move_x = 0;
move_y = 0;

Four variables. move_speed is the horizontal pixels-per-tick the sprite moves when an arrow key is held. jump_speed is the upward velocity applied on space-key press. move_x and move_y store the per-tick movement deltas that the Step event recalculates each frame.

Now add a Step Event (Add Event, pick Step, sub-event Step). The Step event fires roughly 60 times per second (Game Maker’s default room speed). Paste this GML:

// Step Event - obj_player

// 1. Read horizontal input
move_x = keyboard_check(vk_right) - keyboard_check(vk_left);
move_x *= move_speed;

// 2. Check ground + jump
if (place_meeting(x, y + 2, obj_ground))
{
    move_y = 0;
    if (keyboard_check(vk_space)) move_y = -jump_speed;
}
else if (move_y < 10)
{
    // 3. Apply gravity (cap fall speed at 10 px/tick)
    move_y += 1;
}

// 4. Apply movement + collision in one call
move_and_collide(move_x, move_y, obj_ground);

// 5. Flip sprite to face direction of motion
if (move_x != 0) image_xscale = sign(move_x);

Read it block by block.

1. Read horizontal input. keyboard_check(vk_right) returns 1 when the right arrow is held, 0 otherwise; subtracting keyboard_check(vk_left) yields -1 for left, 0 for neither, +1 for right. Multiplying by move_speed scales that into pixels-per-tick.
2. Check ground + jump. place_meeting(x, y + 2, obj_ground) returns true if the sprite would collide with an obj_ground instance if it moved down two pixels — in other words, is there ground directly beneath the player. When grounded, move_y resets to 0 (stops accumulated fall speed), and a space-key press sets move_y to -jump_speed (negative because Game Maker’s y axis increases downward).
3. Apply gravity. The else branch fires when the sprite is not on the ground. move_y increments by 1 each tick, which produces accelerating fall — gravity. The < 10 cap prevents the sprite from falling faster than 10 pixels per tick (terminal velocity); without it, a long fall would clip through thin platforms.
4. Apply movement and collision. move_and_collide(move_x, move_y, obj_ground) is Game Maker’s modern physics primitive (introduced in GameMaker Studio 2022.x, still the canonical call in 2026). It moves the instance by (move_x, move_y) pixels and stops automatically on collision with any obj_ground instance, which means no manual collision-resolution code. The optional last four arguments unlock slope handling: move_and_collide(move_x, move_y, obj_ground, 4, 0, 0, move_speed, -1) caps maximum horizontal and vertical speeds and lets the player slide up gentle slopes without snagging.
5. Flip sprite to face direction. image_xscale is Game Maker’s per-instance horizontal scale; setting it to -1 mirrors the sprite, +1 displays it normally. sign(move_x) returns -1, 0, or 1 depending on the sign of move_x; the if (move_x != 0) guard prevents the sprite snapping back to a default facing when the player releases the arrow key.

Press F5 to run the project. The player sprite drops to the ground (gravity), holds steady until you press an arrow key (horizontal input), walks left or right with the correct facing (image_xscale), and jumps in a clean parabolic arc on space-press only when grounded (jump check). If the sprite tunnels through the floor or hovers above it, double-check the + 2 offset in place_meeting(x, y + 2, obj_ground) — Game Maker’s collision math requires the ground check to look slightly below the sprite, not at its current position.

For the walk-cycle animation, add a second block to the Step event that switches sprite_index based on movement state, using the guard pattern to avoid the most common Game Maker animation bug (sprite flickering because sprite_index is reassigned every frame and resets image_index to zero):

// Walk cycle animation (append to Step Event)
var _target_sprite = spr_player;       // idle default
if (abs(move_x) > 0.5)
{
    _target_sprite = spr_player_walk;  // walking
}
if (sprite_index != _target_sprite)
{
    sprite_index = _target_sprite;
    image_index = 0;                   // restart from frame 0
}

That guard pattern is the single most repeated piece of advice in the Game Maker community knowledge base for animation: only reassign sprite_index when the target sprite actually differs from the current one, otherwise the animation never advances past frame zero.

Step 4 — Add Music, SFX, and a Parallax Background

The platformer code is now functional but silent and visually thin. The audio and background pass is what makes the level feel like a real game.

Music. Open /music-gen in a browser tab. Type a one-sentence prompt: “Upbeat retro chiptune loop, fast tempo, NES-style square wave melody with bouncy bass, two-minute loop, instrumental, no vocals.” Tick the instrumental toggle. Music Gen generates two variations at 10 credits per generation (verified against src/app/music-gen/page.tsx line 26 on 2026-06-08); pick the stronger one and download as MP3. In Game Maker, right-click the Sounds folder, Create Sound, name it snd_level_theme, click the Source button, and select the downloaded MP3. Game Maker auto-decodes MP3 and supports it as a native asset format. To play the loop, add a Room Start event to a controller object (or to obj_player if you prefer) and call audio_play_sound(snd_level_theme, 1, true); — the third argument set to true enables looping.

SFX. Open /sfx-gen and generate four short clips: a jump bloop, a landing thump, a coin chime, a hit grunt. Each clip is a few credits. Trim the results in /sound-creator (Sound Studio) to clean the heads and tails, then export as WAV. In Game Maker, create one sound asset per clip (snd_jump, snd_land, snd_coin, snd_hit). Trigger them from GML at the right moments: audio_play_sound(snd_jump, 5, false); inside the if-keyboard-check-space block in the player Step event fires the jump sound exactly when the jump starts. The hit and coin sounds wire up the same way from collision events.

Parallax background. Open /generate again. Prompt: “Pixel-art forest background, side-view, three layers (distant mountains, midground trees, foreground shrubs), 1920 by 1080 widescreen, retro game aesthetic, no characters.” Pick 16:9 aspect ratio (which fits Game Maker’s default 1080p room dimensions). Generate; download. Optionally pass through True Pixel to lock the palette to match your hero. Import the background into Game Maker via the Sprite Editor (single PNG import, not strip import). In the Room Editor, click the Backgrounds tab, click the empty layer, pick the background sprite. Game Maker handles the visual draw automatically. For true parallax (the background scrolls slower than the player to fake depth), use multiple background layers each with a different Horizontal Speed value in the layer properties — the layer with the slowest speed reads as the most distant.

Total audio and background credit cost: about six to eight credits for the music, eight to twelve for the four SFX clips, and four credits for the background image plus palette pass. The hero plus this full audio-and-background pass fits comfortably inside the 100 starter credits, with margin to roll alternatives.

WizardGenie: The Browser Path That Skips Game Maker Entirely

The pipeline above assumes you want to ship a Game Maker game — a packaged binary that runs natively on Windows, macOS, Linux, Android, iOS, or HTML5. There is an honest alternative path for readers who would rather skip the installer entirely and ship a browser-native platformer that runs anywhere with a URL: Sorceress WizardGenie.

WizardGenie is a vibe-coding harness for game dev. It drives 8 frontier coding models (Claude Opus 4.7, Claude Sonnet 4.6, GPT-5.5, Gemini 3.1 Pro, DeepSeek V4 Pro, Kimi K2.5, Grok 4.2, MiniMax M2.7 — verified against src/app/_home-v2/_data/tools.ts on 2026-06-08) from either a browser tab at /wizard-genie/app or a Windows desktop client (electron-builder native app with filesystem access and longer-running agent sessions). WizardGenie scaffolds the engines indie devs actually ship browser games to: Phaser 4 (the canonical 2D HTML5 game framework), Three.js (for 2.5D and 3D), HTML5 plus the Canvas API, and Pixi.js for 2D-WebGL rendering. The platformer pattern transfers cleanly: the same place-meeting, gravity-velocity, jump-on-ground-press logic that the Game Maker GML version uses ports to JavaScript in a few dozen lines, and WizardGenie writes the JavaScript while you describe the game.

The same Sorceress AI sprite pack from Steps 2 through 4 drops into the WizardGenie path with no changes: the Quick Sprites sheet loads as a Phaser sprite-atlas frame map, the True Pixel hero stays palette-locked, the AI Image Gen background loads as a Phaser Image, the Music Gen MP3 plays through the Sound Studio-trimmed output via the browser’s Web Audio API. WizardGenie’s Dual-agent Planner+Executor mode pairs a frontier planner (Opus 4.7 or GPT-5.5 doing the architecture thinking) with a cheap executor (DeepSeek V4 Pro at roughly a fifth of frontier cost for the line-by-line typing); the cost ratio works out to about one-fifth of single-frontier-model cost for the same playable result. Per the Sorceress lifetime model, $49 one-time at /plans unlocks every non-credit tool forever, and the credit packs cover the generative steps.

The right call between Game Maker and WizardGenie depends on your distribution target. Native EXE plus mobile APK plus HTML5 build from a single GML codebase, with the option to add console export later, points at Game Maker. Single URL that anyone can play in any browser, faster iteration loop, no IDE to install, points at WizardGenie. The Sorceress asset pipeline is identical in both directions.

The Verdict on How to Make a Platformer in Game Maker With Free AI Sprites

The smallest honest answer to how to make a platformer in Game Maker in 2026 is the pipeline above: four variables in the player object Create event, five blocks in the Step event (read input, check ground, trigger jump, apply gravity, call move_and_collide), one sprite-state guard for the walk-cycle animation, and a free AI sprite pack from Sorceress that drops into the Sprite Editor via Import Strip Image. Game Maker’s Free tier covers the entire IDE side at zero cost for non-commercial projects; the Sorceress 100 starter credits cover the entire art and audio side at zero cost for one complete platformer level. Total spend: nothing, until you decide to sell the game (one-time $99.99 Game Maker Professional license) or build a second level (Sorceress credit packs at $10 for 1,000 credits with no expiry).

Three concrete next moves once the first room runs.

• Add a second level. Create a second Room asset, drag a different layout of obj_ground instances, place the player at the start position. Wire room transitions with a goal object and room_goto(rm_level_2); in a Collision event between obj_player and obj_goal. The asset pipeline does not change; the room layout does.
• Add enemies. Create obj_enemy with its own AI Image Gen + True Pixel + Quick Sprites pass (about ten credits). Wire patrol behaviour in the enemy Step event (flip move_x on collision with wall objects). Wire damage on collision with the player Step event using place_meeting(x, y, obj_enemy).
• Ship a build. File, Build, Create Executable (or HTML5, or Android, depending on your target). The Free tier exports run with no watermark or banner; the only restriction is that you cannot sell the binary commercially.

If the project hits the Game Maker installer ceiling and you want to ship a browser-native version of the same game, WizardGenie drives the same pattern in Phaser or HTML5 plus Canvas from a browser tab. The walk-cycle PNG, the palette-locked hero, the parallax background, the level loop, and the SFX clips drop in unchanged — same assets, different engine, same game.

For the asset side, Quick Sprites handles the walk cycles, True Pixel handles the palette lock, AI Image Gen handles the source illustrations and parallax backgrounds, Music Gen handles the level loops, and the full tool list lives at /tools-guide. The honest path from the bare Game Maker IDE to a playable platformer with custom art and audio takes one afternoon, costs nothing if you stay inside the Free tier and the 100 starter credits, and produces a binary that runs anywhere Game Maker exports.