Free game design and development activities for your class

Students take Pong apart, switching graphics, sound, physics, collision, input and rules on and off to see what each layer adds. A good first day, and fine for younger students.

Deconstruct a simple game into its parts.

The game loop: read input, update, draw, sixty times a second. Students watch sprites move by changing x and y, and collisions fire when boxes overlap.

Control a player in a live game loop with highlighted steps, spawn bouncing sprites, and test AABB collision detection interactively.

How a computer draws a line or a circle out of squares: Bresenham's algorithm, mirrored circles and anti-aliasing, ending with students drawing using the algorithms.

How computers draw perfect lines and circles using only square pixels.

Students turn the walking mushroom into a creature of their own, frame by frame, then the class plays all the animations side by side.

Draw a character one square at a time, then make it walk.

Everyone plays Meadow Run, changes one thing, then swaps seats and plays a neighbor's version. Come back after each unit to tune the jump, the enemies and the level.

Build a level, add coins and enemies, then play the game you made.

A light lesson for any age: students hunt for hidden eggs, try the Konami Code, and hear why developers hide surprises in their software.

Software is full of hidden surprises that the people who built it left for curious explorers to find. Discover what an Easter egg is, where the name comes from (a secret room in a 1980 Atari game), crack the famous Konami Code, type secret terminal commands, and learn a few of the eggs hidden right here on this site.

Screen y grows downward, unlike in math class. Students find points on the grid, then meet world and screen coordinates, 3D, polar and texture coordinates.

From Cartesian to polar - understand the grids that power every game and app.

Direction plus size: students add gravity to a jump, normalize so diagonal movement is not faster, check direction with the dot product, and finish with a launcher challenge.

Direction and magnitude - the arrows that power movement in games.

How a turret knows where to aim: degrees and radians, atan2, a capped turn speed, and sin and cos for circling. It ends in a turret defense challenge.

Degrees, radians, and atan2 - the math that makes things turn and aim.

Any two points hide a right triangle. Students use the distance formula the way games do for collision, AI and sound, then take it into 3D.

The ancient formula that calculates distance in every video game.

Gravity, hitboxes, friction on an ice level and momentum on a pool table, then a sandbox where students change the values and see how the game changes.

Gravity, friction, and bouncing - real-world rules that make games feel right.

Box against box, circle against circle, and the tricky box against circle, then compound colliders, click detection and spatial partitioning, all tested in a collision playground.

AABB, circles, and pixels - how games know when things touch.

For older students: cloth as a grid of points joined by constraints and moved with Verlet integration. Pin it, blow wind at it, and tear it.

Discover how physics engines turn a grid of point masses and distance constraints into realistic cloth, capes, and flags using Verlet integration.

Students compare the same motion at 10, 30, 60 and 120 frames per second, then learn about the 16.7 millisecond frame budget and why steady frame times beat a high average.

See the difference between frame rates and understand why smooth motion matters.

Lerp first, then ease in, ease out, bounce and elastic, a race between easings, and a bezier curve to design. Students see what separates stiff motion from lively motion.

Linear is boring - discover the curves that make animations feel alive.

Fire, smoke and sparks taken apart: emitters, lifetimes, gravity, random variation, blending and layers, ending in a particle playground.

Fire, smoke, and sparkles - create visual magic.

The shorter version: move the emitter, click through presets such as fire, and set off bursts with a click. A quick opener before ParticleFX.

Control emitter parameters, explore 6 preset effects (fire, rain, snow, sparks, smoke, magic), and trigger burst explosions.

Everyone starts from the same campfire and changes only numbers to make rain, a fountain or rocket exhaust, then explains which number did the most.

Free, no account. Take a campfire apart layer by layer, flip gravity on the sparks, and fire it once the way a game would.

Each student builds a sound for one game event, like a door opening or a missed jump, and the room guesses the event from the sound alone.

Free, no account. Turn a laser that fires into one that charges up by moving a single slider.

Why game worlds are grids of small repeating squares: tilesheets, row and column positions, and smart tiles that choose an edge or corner from their neighbors.

Discover how tiny repeating tiles build entire game worlds.

Same tileset for everyone and ten minutes to build one screen of a level with a gap to jump, a platform to reach and a reward on top.

Free, no account. Start in Grassy Hills, bridge the water with a block of ground, then hide a layer and see what a level is made of.

Students see why pure random heights look like static, then blend and layer noise and color it by height until a landscape appears.

How a bit of smoothed randomness ("noise") becomes mountains, coastlines, and entire worlds. Learn procedural generation, then grow your own landscapes.

Scatter dots, split the space into Voronoi regions, raise the sea to make a coastline, then place cities and roads by rules. A whole map that nobody drew.

The trick behind map generators: scatter points, split space into nearest-point regions (Voronoi), flood the low ones into coastlines, then place cities and roads by rules. Then generate your own.

Level design in 3D: each student builds a stage a classmate can finish on the third try but not the first, then they trade and explain the hard jump.

Free, no account. The lava is one line of code, and you can open it and change it.

Patrol, chase, flee and wander, then state machines that switch between them. Each pattern matches an enemy behavior students can set in GameBuilder.

Patrol, chase, flee, and wander - bring game characters to life.

Flow, difficulty curves, rubber banding, dynamic difficulty and risk against reward, with Mario Kart and Resident Evil 4 as examples. Students finish by designing a difficulty curve.

Flow state, difficulty curves, and dynamic adjustment.

Why the rare drop never comes: seeds, two-dice sums, the law of large numbers, weighted loot tables, pity systems and shuffle bags. Students end by building a loot table.

Loot tables, critical hits, and pity systems - the math behind game luck.

Click anywhere to read its two numbers, hunt down coordinates on the grid, and find out why screen y grows downward when math class says it grows up.

Click anywhere to see its two numbers, hunt down coordinates you are given, and find out why screen y grows downward when math class says it grows up.

Two runners drop a dot every frame, and the spacing is the speed. Students log races and find the one number that arrives in exactly the time they want.

Race two runners that drop a dot every frame, and watch the spacing tell you the speed. Then find the one number that gets you anywhere in exactly the time you want.

Students drop a ball beside its frame-by-frame table and spot the column that grows by the same amount every row. That column is gravity.

Drop a ball next to its own frame-by-frame table and watch one column count up by the same amount every single row. That column is gravity.

Step through a jump one frame at a time, log jumps of different strengths, and find the rule for picking a jump on purpose. The quadratic from algebra, doing a job.

Step through a jump one frame at a time, measure jumps of different strengths, and find the rule that lets you pick a jump on purpose. The same two lines run every platformer ever made.

The finished platformer, play-only. Press M to see the hitboxes, velocity arrows and the triangle to the nearest coin: the labs above, all running at once.

The platform game from the Build a Game Engine Out of Math course, with every system in place. Play it, then press M to watch the engine: hitboxes, velocity arrows, and the live triangle to the nearest coin.

The capstone for students who wrote the engine in the course: paste engine.js into a new project and build a top-down dodge game without one new function. Anyone can play the result.

Finished the platformer? Paste your engine.js into a fresh project and build a top-down dodge game on it, step by step, without adding a single engine function. If your engine can make a second game, you built an engine.