A small neural network learns to flap through pipes. The Genetic Algorithm (GA) evolves the network's weights between generations.

How it works

1. The network has 5 inputs (the bird's height, velocity, and distances to the next pipe), one hidden layer of 6 neurons, and 1 output. If the output crosses a threshold, the bird flaps.
2. Every member of the population plays a Flappy Bird run. Fitness is the time the bird survives plus a small bonus for each pipe it clears.
3. The top performers are selected as parents. Their weights are recombined and mutated to seed the next generation.
4. You see the current best policy net play live, and a chart tracks fitness over time.

What to watch

• Early generations crash into the first pipe. Within a few generations the bird learns to pace its flaps.
• The fitness curve flattens once the policy is solid; spikes after that are the rare lucky runs.

A small neural network learns to play Snake. The Genetic Algorithm (GA) evolves its weights between generations.

How it works

1. The network has 9 inputs (danger sensors around the head, the food's relative position, and the current heading), one hidden layer of 8 neurons, and 3 outputs: turn left, go straight, turn right.
2. Each member of the population plays a Snake game. Fitness rewards length and time alive while penalising self-collisions.
3. The fittest snakes are selected as parents. Their weights are recombined and mutated to produce the next generation.
4. You see the current best policy net play live, with a fitness chart tracking progress over generations.

What to watch

• The first generations wander aimlessly into walls. Survival times climb as the network learns to avoid danger.
• Once it figures out food, the snake gets longer and longer, and avoiding its own body becomes the hard part.

A small neural network learns to drive a car around a race track. The Genetic Algorithm (GA) evolves the network's weights between generations.

How it works

1. The car senses the track with five distance rays fanned out around its heading, a tiny lidar. Those five readings, plus the car's speed, are the network's 6 inputs. One hidden layer of 8 neurons feeds 3 outputs: steer left, go straight, or steer right. The largest output wins.
2. The car always rolls forward at a steady speed, so steering is the only thing to get right. Every member of the population drives a run. Fitness rewards how far it travels along the track and how many checkpoints it clears. Touching a wall ends that run.
3. The top performers are selected as parents. Their weights are recombined and mutated to seed the next generation.
4. You see the current best network drive live, with its sensor rays drawn on the track, and a chart tracks fitness over time.

What to watch

• Early generations veer straight into the first wall. Within a few generations the car learns to hug the racing line and complete laps.
• The sensor rays show what the car "sees". Watch how it starts braking its turns earlier as the policy improves.
• The fitness curve climbs as cars survive longer, then flattens once a clean lap becomes routine.

A small neural network learns to play an endless runner, jumping over cacti and ducking under flying obstacles. The Genetic Algorithm (GA) evolves the network's weights between generations.

How it works

1. The network reads 7 inputs about the next obstacle (how far ahead it is, whether it sits on the ground or flies, how tall it is) plus the dino's own state and the current speed. One hidden layer of 8 neurons feeds 3 outputs: run, jump, or duck. The largest output wins.
2. The catch is that the two obstacle kinds need opposite reactions. A cactus has to be jumped (ducking still hits it); a flying obstacle has to be ducked (jumping rises straight into it). So the network has to read the obstacle and pick the right move, then time it.
3. Every member of the population plays a run. Fitness is how long the dino survives plus a bonus for each obstacle it clears. The course speeds up the longer it lasts, so later obstacles arrive faster.
4. The top performers are selected as parents. Their weights are recombined and mutated to seed the next generation.

What to watch

• Early generations trip at the first hurdle, often jumping into a bird or running into a cactus.
• Within a few generations the population learns to tell the two obstacles apart and reacts to each correctly.
• As the policy gets solid, runs get long and the speed keeps climbing until the run finally ends.

A small neural network learns to play Breakout, sliding a paddle to keep a bouncing ball in play while it smashes a wall of bricks. The Genetic Algorithm (GA) evolves the network's weights between generations.

How it works

1. The network reads 5 inputs: the ball's position and velocity, and the paddle's position. One hidden layer of 8 neurons feeds 3 outputs: move left, stay, or move right. The largest output wins.
2. The network never sees the bricks. Its only job is to keep the ball alive by getting the paddle under it. The bricks break on their own when the ball reaches them, so the wall clears as a side effect of good paddle play.
3. Every member of the population plays a run. Fitness is how long the ball stays in play plus a bonus for each brick broken and each paddle hit. A miss ends the run.
4. The top performers are selected as parents. Their weights are recombined and mutated to seed the next generation.

What to watch

• Early generations leave the paddle parked and miss the ball almost at once.
• Within a few generations the paddle starts shadowing the ball, and rallies stretch out as the wall comes down.
• Clear the whole wall and a fresh one drops in, so a strong policy just keeps going.

A small neural network learns to play Pong, sliding the left paddle up and down to keep returning a bouncing ball against an opponent. The Genetic Algorithm (GA) evolves the network's weights between generations.

How it works

1. The network reads 6 inputs: the ball's position and velocity, and both paddle positions. One hidden layer of 8 neurons feeds 3 outputs: move up, stay, or move down. The largest output wins.
2. The opponent paddle always returns the ball, so a rally ends only when the agent misses. The agent's only job is to get its paddle in front of the ball every time it comes back.
3. Every member of the population plays a run. Fitness is how long the rally lasts plus a bonus for each successful return. A miss ends the run.
4. The top performers are selected as parents. Their weights are recombined and mutated to seed the next generation.

What to watch

• Early generations leave the paddle parked and miss the first ball.
• Within a few generations the paddle starts shadowing the ball, and rallies stretch out.
• A strong policy keeps the ball in play for long, fast rallies that only end at the step cap.

A small neural network learns to steer across an open grid to reach a gem. Collect it and a new gem appears, so the agent keeps navigating. The Genetic Algorithm (GA) evolves the network's weights between generations.

How it works

1. The network reads 6 inputs: whether each of the four neighboring cells is blocked, plus the direction to the gem (left/right and up/down). One hidden layer of 8 neurons feeds 4 outputs: move up, right, down, or left. The largest output wins.
2. The grid is dotted with blocks the agent must steer around to reach the gem. You can set how many blocks appear in Settings, and each run lays out a fresh random arrangement. The blocked-cell sense tells it which neighbors are impassable, so it learns to route around blocks rather than only following the gem direction.
3. Every member of the population plays a run. Fitness rewards getting closer to the gem and collecting it; wandering without progress ends the run.
4. The top performers are selected as parents. Their weights are recombined and mutated to seed the next generation.

What to watch

• Early generations wander and drift into the edges.
• Within a few generations the agent starts heading straight for the gem.
• A strong policy collects gem after gem, routing cleanly around the blocks each time.
• The gems move to fresh spots each cycle. The network only senses the blocks next to it and the direction to the gem, with no memory of past positions, so reaching the new gems shows it learned to navigate in general rather than memorize one fixed route.

A small neural network learns to time its way across six lanes of traffic to reach the far side. Reach the top and it starts over from the bottom. The score is how far it safely advances: every step it moves up without getting hit counts (a full crossing is worth twelve), so partial progress shows even before it completes a crossing. The Genetic Algorithm (GA) evolves the network's weights between generations.

How it works

1. The network reads 6 inputs: whether it is on a lane, whether the next row up is a lane, the gap and direction of the nearest car in that lane, the gap in its current lane, and how far up it has progressed. One hidden layer of 8 neurons feeds 2 outputs: move up or stay. The larger output wins.
2. Safe medians sit between the car lanes, so the agent only ever spends a single step on a lane. The one decision that matters is whether it is safe to step onto the next lane right now, which it reads from the oncoming car.
3. Every member of the population plays a run. Fitness rewards upward progress and full crossings; getting hit ends the run.
4. The top performers are selected as parents. Their weights are recombined and mutated to seed the next generation.

What to watch

• Early generations step into traffic and get hit almost at once.
• Within a few generations the agent starts waiting on the medians and dashing through the gaps.
• A strong policy threads lane after lane, crossing back and forth without a scratch.

A population of random wheeled vehicles tries to roll across uneven terrain. The Genetic Algorithm (GA) keeps what works and breeds new variants.

How it works

1. Each chromosome encodes a vehicle: body polygon shape, wheel positions, wheel radii, and motor strengths.
2. Each vehicle is dropped onto the terrain and runs until it falls, stops, or hits the time limit.
3. Fitness is how far the vehicle traveled along the course before its run ended.
4. The fittest vehicles become parents; their offspring inherit a blend of their traits with small random changes.

What to watch

• The leader board updates after every generation. The current best is shown rolling in the foreground.
• Early generations produce comical failures. After a dozen or so, designs that look almost intentional take over.

The simulation runs live in your browser. No sign-in needed.

A rocket spawns near the top of the canvas with random drift and has to land softly on a pad below. The Genetic Algorithm (GA) evolves a thrust and gimbal program that pulls off the landing.

How it works

1. Each chromosome is sixteen real numbers in [0, 1]: eight evenly-spaced control points with a thrust value and a gimbal value at each.
2. Fifteen rockets fall through the same conditions at the same time so you can compare their programs.
3. Crashes score zero. Clean landings score by softness, uprightness, and how centred they touched down.
4. The fittest programs become parents; their children inherit a mix, then a few values drift slightly.

What to watch

• Generation zero is chaos. After a handful of generations a few rockets pause near the pad and fire short bursts to settle.
• The history strip under the canvas keeps the best descent from each generation.

Runs live in your browser. No sign-in needed.

A rigid road stretches across a gap. Each walker is a jointed human figure: head, torso, two arms, and two legs with knees and feet. Every figure already knows how to walk. The Genetic Algorithm (GA) reshapes its body, leg length, height, build, and posture, and the right body is the one that crosses the holes and ducks the wrecking balls.

How it works

1. The road is a rigid deck of wooden planks fixed between two cliffs. It does not sag, sway, or bounce, so getting across is down to how the walker is built.
2. Some planks are missing, leaving holes. A walker strides across a hole only if its legs are long enough to reach the far side. Short-legged ones fall in. You set how wide the holes can be.
3. Heavy wrecking balls swing across the deck on chains. A longer chain hangs the balls lower, so a tall walker gets clipped while a short or low-standing one passes under. A struck walker crumples and falls.
4. The walk itself is built in and the same for everyone, so the figure always moves cleanly. The GA changes only the body, leg length, torso height and width, foot size, head size, and how upright it stands, and those proportions decide its stride and height, and therefore which holes it clears and whether it ducks the balls.
5. Fifteen walkers step out at the same time so you can see the leader pull ahead.
6. Fitness is how far the walker travelled before falling off the road.

What to watch

• Generation zero is mixed: short-legged ones drop into the first hole, tall ones get swept off by a ball. Over generations the population reshapes toward a body that fits the road, often long legs to span the holes on a low frame that slips under the balls.
• A taller body reaches farther but is easier for a ball to hit; a lower one ducks the balls but needs long enough legs to still span the holes. The GA finds the balance.
• The history strip under the canvas keeps the best walker from each generation, so you can watch the winning body shape change.

Runs live in your browser. No sign-in needed.

A spacecraft launches into a small solar system — one sun, four planets in circular orbits — and has to visit four fixed beacons scattered across deep space. The mission has a six-year window and a fuel budget, and one wrong turn flings it into the sun or off the edge of the map. The Genetic Algorithm (GA) decides what to do at every step of the way.

How it works

1. Each Reset reshuffles the seed. The same physics applies every time, but the launch pad shifts, so a plan from one run won't transfer to another.
2. Every roughly 0.1 simulated years the rocket pauses, and a fresh GA runs on our servers. It searches over candidate burns — a direction and a magnitude — starting from the spacecraft's actual current position, velocity, and remaining fuel.
3. The browser scores every candidate by simulating the next several months of flight through real Newtonian gravity. Sun crashes are heavily penalized, planet crashes less so, and progress toward the nearest unvisited beacon is rewarded.
4. The server picks the best burn and sends it back. The rocket applies the impulse and continues until the next decision point. This is closed-loop control: the GA always sees the live state, instead of trying to plan the whole mission in advance.
5. Each candidate has only two genes (burn direction and magnitude), so each inner GA converges in just a few generations and a fraction of a second.

What to watch

• While the rocket is paused at a decision point, faint trails appear from the craft. Each is a candidate burn the GA is considering; the brightest one is the current best.
• Once the rocket resumes, watch the beacons flip from green rings to gold checkmarks as the craft sweeps through them.
• Look for the trail kinking near a planet. The GA discovers gravitational slingshots — passing close at the right relative velocity to steal orbital energy — without being told they exist. Same trick NASA used to fly Voyager past the outer planets.
• Visiting all four beacons in one episode is the Grand Tour achievement.

Runs live in your browser. No sign-in needed.

A delivery drone has to visit a set of stops on a 2D map and return to its depot. The Genetic Algorithm (GA) evolves the order it visits them in, looking for a short tour.

How it works

1. Each chromosome is a permutation of the ten stop indices. The depot is the implicit start and end of every tour.
2. Fifteen tours fly across the map at the same time so you can see the leader pull ahead.
3. Fitness is the inverse of the total flight distance. Shorter tour, higher fitness.
4. The fittest tours become parents; their children inherit a mix of both visit orders, then a few stops are swapped at random.

What to watch

• The first generation looks like spaghetti. After a handful of generations the leader's path tightens up.
• The history strip under the canvas keeps the best tour from each generation so you can scroll back and watch the shape converge.

Runs live in your browser. No sign-in needed.

A real maze is generated fresh every run, with one path from the start corner to the exit corner. The Genetic Algorithm evolves a plan: a fixed list of moves (up, right, down, left) that the walker follows step by step. There is no per-step thinking. The whole route is decided in advance, and the GA improves that route generation by generation.

How it works

1. Each candidate is a sequence of moves. The walker follows it from the start; a move into a wall is wasted (it stays put), which is what pushes the GA to learn the corridors.
2. Fitness rewards getting closer to the exit, with a large jump for reaching it and a bonus for reaching it in fewer steps.
3. The fittest plans become parents. Their moves are recombined and mutated to seed the next generation.
4. Press Reset for a brand new maze and a fresh population.

What to watch

• Early generations stall in dead-ends and bounce off walls.
• The best plan steadily reaches deeper into the maze.
• Eventually a plan threads the whole maze to the exit, then later plans do it in fewer steps.

A 2D map has a few rectangular obstacles that block radio signal. The Genetic Algorithm (GA) places a handful of antennas (configurable in Settings, default 7) to cover as much of the open area as possible.

Goal: 100% coverage of the open area.

The GA could trivially hit that by cranking every antenna to maximum range and stacking them all in the centre, so three penalties keep it honest:

• Overlap. Covering the same patch with two or more antennas doesn't add anything, so it costs fitness.
• Power. A wider broadcast range costs more, so each extra unit of range has to be justified by extra fresh coverage.
• Spread. Antennas that sit too close to a neighbour pay a clustering tax, so the GA is pushed to fan them out instead of piling several into one dense spot and leaving big regions empty.

To beat all three at once the GA has to evolve layouts where every antenna's position, radius, and spacing pulls its weight.

What to watch

• Early layouts miss whole regions or pile every antenna onto the same spot. After a handful of generations the leader's circles tile the open area with each circle sized for its neighbourhood.
• The history strip under the canvas keeps the best layout from every generation so you can scroll back and watch placement converge.

Runs live in your browser. No sign-in needed.

A Genetic Algorithm (GA) repaints a target image one brushstroke at a time, learning where each stroke should go.

How it works

1. You pick a target image and a brush style.
2. Each chromosome encodes a single stroke: brush identifier, position, scale, and rotation angle.
3. Fitness rewards strokes whose pixels move the in-progress canvas closer to the target.
4. The best stroke is painted onto the canvas, and the GA starts over to pick the next stroke. Hundreds of strokes later, the painting emerges.

What to watch

• The first strokes lay down broad regions of color. Later strokes refine edges and detail.
• The "best stroke so far" preview shows the candidate the GA is currently optimizing.

You can pause, change the brush, or load a new target at any time. No sign-in needed.

The classic 3×3 sliding-tile puzzle, solved one move at a time by a Genetic Algorithm (GA).

How it works

1. Each chromosome is a sequence of up to 20 moves (Up, Down, Left, Right) that the blank should slide.
2. Fitness rewards low Manhattan distance to the goal state. The closer the resulting board is to solved, the better.
3. The GA runs for up to a couple of seconds, picks the best sequence, and we play the first legal move on screen.
4. Click Auto-solve. The loop replans from each new state every 600 ms until the goal is reached, or hit Stop auto to pause it.

Highlights

• The two cells just swapped are highlighted on the board.
• The Last swap row in the GA result panel shows which tile changed places with the blank.

Click Scramble at any time for a fresh solvable board.

This demo walks through a Genetic Algorithm (GA) one lifecycle stage at a time so you can see exactly what happens between generations.

Problem: evolve a population of strings until one matches a target you provide (default CAIRO). Each chromosome is a list of letters; fitness is the number of characters that match the target at the same position.

Stages (shown as a badge on the right panel):

• init, random initial population (not yet evaluated). Click Next to score it.
• fitness, score every chromosome against the target.
• select_parents. Pick the chromosomes that breed (highlighted + underlined).
• crossover, combine parents into offspring; cut points appear as red dashed lines.
• mutation, perturb random genes; mutated positions are tinted and underlined.
• update_population, install offspring as the new generation; elitism keeps the best.

Open Settings to tune hyperparameters, then click Reset / Initialize, then Step (Next) repeatedly to advance one stage at a time. The chart at the top tracks the best fitness across generations.

Play Connect Four against an opponent whose evaluator is re-evolved by a Genetic Algorithm (GA) every turn.

How it works

1. Click any empty cell in a column to drop your piece into that column.
2. Once your piece lands, the agent runs a short GA (under three seconds) to evolve weights for a hand-designed evaluator (center control, 2- / 3-in-row counts for both sides, blocked threats).
3. The agent then picks the highest-scoring legal move with those weights and drops its piece. Its top-3 candidate moves and the evolved weights appear in the right panel.
4. The cycle repeats until someone wins or the board fills up.

Controls

• Human first / Agent first. Pick who opens the next game.
• New game. Start over with a fresh board.

Yellow is player 1, red is player 2.

CoinTex is a top-down arcade game. You move around each level to collect every coin before the timer runs out, while dodging monsters and sweeping fire. A limited gun helps clear the path.

The automatic player

CoinTex ships with an automatic player that plays for you. Many times a second it reads where the coins, monsters, and fire are, weighs a wide range of places it could move to next, scores each one for how safe and rewarding it is, and commits to the best. As the board changes it keeps re-planning. You can set its play style and how quickly it reacts.

This page links to the game on Google Play, downloads for desktop and other platforms, and the open-source code.

SwellFire is an auto-runner. Your squad runs forward on its own and you steer left and right. Gates appear in pairs and change the squad size, some grow it, some shrink it, so the gate you pick matters. The squad fires at enemies automatically on the way to the boss.

The automatic player

SwellFire ships with an automatic player that steers for you. As each pair of gates approaches it weighs every position it could move to, scores them by how much the squad would grow or shrink, and steers toward the best gate (or deliberately between both when each would shrink the squad). It commits early and keeps re-planning as new gates come into view. You can set its play style and how quickly it reacts.

This page links to the game on Google Play, downloads for desktop and other platforms, and the open-source code.