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, with the rest of the generation flying the same pipes as faint birds (switch off Show all birds to hide them), 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. For each of its three moves (turn left, go straight, turn right) the snake senses three things: is it dangerous (a wall, its body, or a dead end), does it bring it closer to the apple, and how much open space does it lead into. One small network (3 inputs, 8 hidden neurons, 1 output) scores each move from those readings, and the best move wins.
2. Each member of the population plays a Snake game. Fitness rewards eating food and every step toward it, costs a little for steps away, and penalises crashing into a wall or the snake's own body.
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 mostly wander until they are stopped for making no progress. Within a cycle or two the best snake hunts down apple after apple.
• The snake grows long and keeps clear of its own body, playing on until the two minutes are up.

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

Pick one of five tracks above the canvas before you start. They range from a wide, forgiving speedway to tight hairpins and a road that pinches at every corner, so you can see how the same algorithm copes with easier and harder worlds.

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 the rest of the generation driving beside it as faint cars (switch off Show all cars to hide them), 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, usually running into a cactus.
• Within a few cycles the best dino learns to time its jumps. Many champions crouch the whole way, which slips under every flying obstacle, and only stand up to jump a cactus.
• Once the policy is solid, the best dino lasts the whole two-minute replay at top speed.

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 7 inputs: the ball's position and velocity, the paddle's position and speed, and how far the paddle is from where the ball will land. One hidden layer of 8 neurons feeds 3 outputs: push left, ease off, or push right. The largest output wins. The paddle has momentum, so it speeds up and slows down smoothly like a hand on a controller.
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, with a small cost each time the paddle turns around so smooth play wins over twitchy play. 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 mostly miss the ball almost at once.
• Within a few cycles the paddle starts shadowing the ball and rallies stretch out, until the best paddle keeps the ball in play for the whole two minutes. Each paddle is tested on two full-length serves, so the champion you watch has earned it.
• 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 7 inputs: the ball's position and velocity, its paddle's position and speed, and how far the paddle is from where the ball will arrive. One hidden layer of 8 neurons feeds 3 outputs: push up, ease off, or push down. The largest output wins. The paddle has momentum, so it speeds up and slows down smoothly like a hand on a controller.
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, with a small cost each time the paddle turns around so smooth play wins over twitchy play. 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 the whole two-minute game. Each paddle is tested on two full-length serves, so the champion you watch has earned it.

A small neural network learns to steer across a grid, past patrolling monsters, 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 among the open moves wins, so it never walks into a block or the edge.
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. The cell it just left also counts as blocked (unless it is the only way out), which stops it from stepping back and forth beside a block.
3. Monsters patrol back and forth along a row or column, and touching one ends the run. The agent senses which moves would walk into a monster, and one extra gene, its fear of monsters, sets how much it avoids those moves. Random agents start with any fear at all, even none.
4. Every member of the population plays a run. Fitness rewards getting closer to the gem and collecting it; wandering without progress, or going round in a loop, ends the run.
5. The top performers are selected as parents. Their weights are recombined and mutated to seed the next generation.

What to watch

• Early generations wander or circle and the run ends quickly.
• Within a few generations the agent starts heading straight for the gem.
• A strong policy collects gem after gem for the whole two-minute game, routing cleanly around the blocks each time. Each explorer is tested on two full-length runs, so the champion you watch has earned it.
• 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 get a frog across four lanes of traffic and a river to one of three home bays at the top. On the river it can only stand on the drifting logs, and a log carries it along, so it has to hop left and right as well as up. Reach a bay and it starts over from the bottom. The score is how far it safely gets: every row it reaches for the first time counts (a full crossing is worth twelve), so partial progress shows before it completes a crossing. The Genetic Algorithm (GA) evolves the network's weights between generations.

How it works

1. The network reads 15 inputs: whether the frog is on the road or a log and how long it can safely stay put; for the next row up, what kind of row it is and how many steps until a hop up, up-left or up-right would be safe; the same for the row after that; how far it is from the nearest home bay; and where it is across the screen and how far up. One hidden layer of 8 neurons feeds 4 outputs: hop up, left or right, or wait. The larger output wins.
2. Fast and slow lanes sit side by side, so a gap that is safe on one lane is not on the next. On the river, open water drowns the frog, a log that drifts too far carries it off the edge, and hopping into the top row anywhere but a home bay hits the hedge.
3. Every member of the population plays a run. Fitness rewards each new row and full crossings; getting hit, falling in or missing the bays 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 hop into traffic or straight into the water.
• For several cycles the frog usually gets a crossing or two and then fails on the river, often by riding a log away from the bays.
• A strong policy waits for its gaps, steps along the logs to line up with a bay, and crosses again and again.

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.

Rockets launch high on one side of a mountain and have to land on a small pad on the other side, through a crosswind, on a limited tank of fuel. The pad, the mountains, the launch point and the wind change every generation, so a rocket can't memorize a route. The Genetic Algorithm (GA) has to evolve a flight computer that works on terrain it has never seen.

How it works

1. Each chromosome is fifteen numbers in [0, 1]. They are the settings of the rocket's flight computer: how hard to steer toward the pad, how much clearance to keep over the ridge, how fast to descend, how strongly to correct tilt, and the throttle that holds a hover.
2. Every moment of the flight, the flight computer reads the rocket's sensors (where the pad is, its speed, its tilt, how high it is above the ridge) and sets the throttle and the engine's angle.
3. A landing counts only if the rocket touches down on the pad slowly, nearly upright, and before its fuel runs out. Clean landings score between 1 and 2 by softness, centring and fuel left. Crashes score below 1 by how close and how slowly they got to the pad.
4. The fittest flight computers become parents; their children inherit a mix of settings, and a few settings are nudged by a small random amount.

What to watch

• Generation zero mostly flies off the edge, falls short into the mountain, or slams into the pad. Within about ten generations the first rockets climb over the ridge, slow down and settle on the pad.
• The history strip below the canvas shows each generation's terrain with its best flight. The terrains keep changing while the landings keep coming, which is the point: the GA found a flight computer, not a route.

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 is thrown off its feet 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, each in its own colours, so you can see the leader (marked with an arrow) pull ahead. The flags show the target distance and the best distance reached so far.
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.

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 a belt of twelve asteroids) and has to visit four beacons scattered across deep space. The mission has a twenty-year clock and a fuel budget, and one wrong turn flings it into the sun, into a rock, or off the edge of the map. Every body, the rocket included, is exactly as big as it is drawn, so a pass that looks like a hit is a hit. 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 and the beacons move, so a plan from one run won't transfer to another.
2. Every 0.1 simulated years the rocket gets a new burn. A fresh GA runs on our servers while the rocket coasts, searching over candidate burns (a direction and a magnitude) from where the spacecraft will be, with the fuel it has left.
3. The browser scores every candidate by simulating the next several months of flight through real Newtonian gravity. Sun crashes are heavily penalized, planet and asteroid 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

• Trails fan out from the craft while the GA plans. Blue ones are safe candidate burns and the gold one is the current best. Red ones end in a crash, with an X where they hit. The launch is planned slowly so you can watch it: the first rounds are mostly red, and evolution finds a safe launch before the rocket flies. The Burn Plan panel counts the crashes in each round and in the whole mission, and says what the chosen burn is forecast to do.
• Once the rocket resumes, watch the beacons turn solid green with a check mark as the craft sweeps through them. The dashed circle inside each beacon is the real zone the craft has to pass through.
• 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. Each generation has fifteen tours. They are all drawn on the map, and the drone flies the shortest one, accelerating, braking and hovering at each delivery stop.
3. Fitness is the inverse of the total flight distance. Shorter tour, higher fitness.
4. The fittest tours become parents. A child keeps a stretch of one parent's route and visits the other stops in the order the other parent does, then a random stretch of the route is flown in reverse, the move that untangles a route that crosses itself.

What to watch

• The first generation looks like spaghetti. After a handful of generations the bold route tightens up and stops crossing itself, and it often ends on the shortest tour there is.
• The goal is a route 35% shorter than an average random one on this map. The readout marks it when a tour gets there.

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

A hedge maze is generated fresh every run, with one path from the mouse's hole in the top-left corner to the cheese in the bottom-right. The Genetic Algorithm evolves a plan: a signpost in every cell that tells the mouse which way to go. 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 one signpost per cell. Each time the mouse stands on a cell, its signpost picks one of the open ways on, or turns back the way the mouse came. Random plans dither and double back; good plans learn which branch to take at each fork.
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 wander into dead ends and double back.
• The best plan steadily reaches deeper into the maze, and with Show all paths on you see every other plan of the generation spread out behind it.
• Eventually a plan threads the whole maze to the cheese and its route glows. Later plans do it in fewer moves until the route is the shortest one: compare Plan with Shortest in the stats bar.

A city block seen from above has a few buildings 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 towers cover the open streets, each sized for its neighbourhood, and the red "no signal" patches shrink to the shadows behind buildings.

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. Every stroke uses the same round brush, always the same size and never rotated.
2. Each chromosome encodes a single stroke with just two genes: where it goes across and where it goes down. Its colour is picked up from the target at that spot.
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 block in the main colors. Later strokes refine edges and detail.
• The strip on the painting and the readout below it count the strokes painted and show how much closer the painting has come to the target. The bar under the painting fills as the run nears its time or stroke limit.

You can pause and resume at any time. To try another picture, pick it once the run is stopped or finished. Reset clears the painting, including after a run has finished. 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 chooses up to 20 legal blank slides, avoiding immediate undo moves.
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 Step for one GA move, or Auto-solve to let it finish. The loop searches from each new state until it finds a complete solving sequence, then follows that verified plan. Stop auto pauses it and Resume auto continues from the same board.

Play along

• Click any tile next to the empty square to slide it yourself. The GA picks up from wherever you leave the board.
• The tile that just moved is highlighted, and arrows show the direction a tile slides.
• The move counter tells you how many moves the solve took.

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, and its fitness is the number of letters that match the target in the same position. The run stops as soon as one string matches the target exactly.

Stages (shown as a badge at the top of the stage panel):

• Initial Population. Random strings, not yet scored.
• Fitness. Every string is scored against the target. Matching letters are tinted.
• Select Parents. The strings chosen to breed are highlighted.
• Crossover. Parents are combined into offspring. Cut points appear as dashed lines.
• Mutation. Random letters change. Mutated positions are tinted and underlined.
• Next Generation. The offspring become the new population, and elitism keeps the best.

A run starts when the page opens. Click Step (Next) to move one stage at a time, Prev to look back, or Play to let it run on its own (choose every stage or a whole generation per tick). Open Settings to change the run, then click Reset / Initialize. The chart tracks the best fitness across generations.

You play Connect Four against an agent whose evaluator is re-evolved by a Genetic Algorithm (GA) every turn. This demo needs you: the agent never plays on its own, it only replies to your moves.

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 (from half a second on Easy to about six seconds on Hard) 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 three candidate moves and how much it valued each board feature appear in the right panel. When someone wins, the winning line lights up.
4. The cycle repeats until someone wins or the board fills up.

Controls

• You go first / Agent goes 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.