kidscancodeBeta

The curriculum

55 units, in 37 sections, and 144 bite-sized, hands-on lessons that teach how computers really work — inspired by Harvard's CS50, made for kids aged 8–10. Each lesson takes about 5 minutes.

Try the first lesson free — no account needed

🧠 Track A: CS Foundations

The mental models behind every computer, game and app.

  1. 💻 Computers & Information — A computer takes in information, follows instructions, and gives information back.
  2. 📦 Memory & Data — Information has to live somewhere: addresses, variables and lists. After: Computers & Information
  3. 🧭 Algorithms & Problem Solving — Precise steps that solve problems: searching, sorting and getting faster. After: Memory & Data
  4. 🔤 Programming Languages — Why languages exist: from machine instructions up to Python. After: Algorithms & Problem Solving
  5. 🧩 Programming Concepts — The building blocks of programs: loops, decisions, functions and debugging. After: Algorithms & Problem Solving, Programming Languages
  6. 🌐 The Internet — How computers talk to each other, with multiplayer games as the example. After: Programming Concepts
  7. 🏗️ Software & Applications — How programs team up: front end, back end, APIs and databases. After: The Internet
  8. 🤖 Artificial Intelligence — How machines learn: data, models, training, neural networks and LLMs. After: Software & Applications

🎮 Track B: Game Development

Use the foundations to build games from simple systems.

  1. 🧱 Game Composition — Player, world, rules, goals and feedback. After: Programming Concepts, Software & Applications
  2. 🔄 Game Loops & State — Tick by tick: input, update, draw. After: Programming Concepts
  3. 📍 Coordinates & Movement — X/Y positions and velocity. After: Algorithms & Problem Solving, Programming Concepts
  4. 🕹️ Input & Events — Keys, taps and the code that answers them. After: Game Loops & State
  5. 💥 Collision & Physics — Boundaries, gravity, bounce and friction. After: Coordinates & Movement
  6. 🧙 NPCs & Algorithms — Characters that decide and find their way. After: Coordinates & Movement, Artificial Intelligence
  7. 🎒 Inventory & Game Data — Lists, objects and maps for items. After: Game Composition
  8. 🏁 Levels & Progression — Difficulty, unlocks, checkpoints and saves. After: Inventory & Game Data
  9. 👥 Multiplayer — Clients, servers, latency and who is in charge. After: The Internet, Software & Applications, Game Loops & State
  10. 🏛️ Game Architecture — A game is many systems, not one giant block of code. After: Software & Applications, Levels & Progression
  11. 🚀 Build Your Own Game — Turn a big idea into small, understandable systems. After: Game Architecture

✨ Track C: AI-Assisted Development

Direct AI to build software, then check that it really works.

  1. 🧩 AI in Programs — AI as one part inside a program that still owns the rules. After: Artificial Intelligence
  2. 📝 Prompting & Specifications — A good prompt is a good specification. After: Algorithms & Problem Solving, AI in Programs
  3. ⌨️ Code Completion — What autocomplete can and cannot do. After: Programming Concepts, Prompting & Specifications
  4. 🛠️ Code Generation — Generated code is an implementation, not proof. After: Code Completion
  5. 🔎 AI as Teacher & Debugger — Ask good questions, then check the answers. After: Code Generation
  6. 🪓 Software Decomposition — Turn “build a game” into parts you can test. After: Software & Applications, Prompting & Specifications
  7. 🌊 Vibe Coding — Idea, spec, build, run, diagnose, refine. After: Software Decomposition, AI as Teacher & Debugger
  8. 🤝 Agentic Development — AI that plans, edits, tests and retries. After: Vibe Coding, Artificial Intelligence
  9. 🏗️ Building With AI — A whole project, directed by you. After: Agentic Development
  10. ✅ Testing & Verification — Know it works, don't just hope. After: Building With AI

🔌 Track D: Electronics & Gadgets

How real gadgets work inside, all the way to designing your own handheld game.

  1. ⚡ Electricity & Circuits — Loops, switches and short circuits, and the volts, amps and ohms engineers design with.
  2. 🔀 Logic Gates — Switches that make decisions, game rules built from gates, and a circuit that adds. After: Electricity & Circuits
  3. 🧩 Transistors & Chips — Switches flipped by electricity, gates and memory built from them, and how billions make a chip. After: Logic Gates
  4. 🍞 From Breadboard to Chips — Build real circuits on a breadboard, from a handful of transistors to logic chips, with a parts list for each. After: Transistors & Chips
  5. 🕹️ Inputs & Sensors — Buttons, joysticks and sensors: how a gadget notices the world. After: Electricity & Circuits
  6. 🔊 Lights, Sound & Motion — LEDs, screens, speakers and rumble motors: how a gadget talks back. After: Electricity & Circuits
  7. 🤖 Microcontrollers — A tiny computer with pins: code that reads buttons and lights LEDs. After: Logic Gates, Inputs & Sensors, Lights, Sound & Motion
  8. 🎮 Design a Gadget — Plan your own handheld game: requirements, a block diagram, a power budget, then test it. After: Microcontrollers

Unit 1💻 What is a computer?

Information goes in, instructions run, information comes out.

  1. What is a computer? — Put information in, follow instructions, get information out.

Unit 2💡 Binary

How computers count with just 0 and 1.

  1. Light switches — Computers are built from tiny on/off switches called bits.
  2. Bits make numbers — Each bit is worth double the one to its right: 1, 2, 4, 8…
  3. Counting in binary — Watch the pattern as a computer counts up one at a time.
  4. How big can it get? — More bits means bigger numbers — and what happens when you run out.
  5. Letters are numbers — How a computer stores text using a secret number code.

Unit 3🖼️ Pixels & Colours

How screens show pictures using numbers.

  1. Pictures are grids — Every picture on a screen is made of tiny squares called pixels.
  2. Pixels are bits — A black-and-white picture is just rows of 0s and 1s.
  3. Mixing light — Every colour on a screen is a mix of red, green and blue light.
  4. How big is a photo? — Count the bytes in a picture — and see why photos get squashed.

Unit 4🎮 Everything is data

Numbers can stand for letters, colours and even a whole game.

  1. Everything becomes data — The same numbers can mean a letter, a colour or a sound.
  2. What does a game know? — Position, health and score are all just values in memory.

Unit 5📦 Memory

Where computers keep things — boxes, addresses and variables.

  1. Bits make bytes — Memory is a huge row of bytes, each holding a number from 0 to 255.
  2. Mailboxes & addresses — Every box in memory has a number, called its address.
  3. Store and fetch — Reading and writing memory — and why writing erases what was there.
  4. Variables are named boxes — Programmers give memory boxes names so they're easy to remember.
  5. Running out of room — What happens when a number is too big for its box.

Unit 6🚃 Arrays

Lists of things, side by side in memory.

  1. Lists in a row — Keep lots of values together, each with its own index.
  2. Change, add, remove — Lists can grow, shrink, and have their items changed.
  3. Side by side in memory — Why lists are fast, and why indexes start at 0.
  4. Lists in Python — Make, read and grow lists in real code.

Unit 7👉 References

Variables can point at things in memory instead of holding them.

  1. Two names, one list — A variable can hold the address of a list. Two variables can hold the same address.

Unit 8🎒 Game data in memory

Players, enemies and items are variables and lists, nested together.

  1. Inventories and enemies — How a game keeps its players, items and enemies in memory.

Unit 9🧭 Thinking in steps

Algorithms are precise steps, and big problems break into small ones.

  1. What is an algorithm? — Precise steps that turn an input into the result you want.
  2. Breaking problems down — Split a big job into small tasks and work out what must come first.

Unit 10🔍 Searching

Smart ways to find things fast.

  1. Find the card — The simplest way to search: check every item, one by one.
  2. The worst case — Computer scientists plan for the unluckiest search possible.
  3. Sorted helps — When things are in order, every guess tells you which way to go.
  4. Binary search — Look in the middle, throw away half, repeat.
  5. The great race — Linear search vs binary search on really big lists.

Unit 11📊 Sorting

Clever ways to put things in order.

  1. Why sort? — Putting things in order makes them much faster to search.
  2. Bubble sort — Swap neighbours that are in the wrong order until everything's sorted.
  3. Selection sort — Find the smallest, put it first, and repeat.
  4. Which is faster? — Why some sorting algorithms beat others on big lists.

Unit 12🗺️ Pathfinding

How a game character finds its way.

  1. Finding a route — How a game character works out the shortest way around walls.

Unit 13🏎️ Efficiency

Why some algorithms get slow as problems grow.

  1. Algorithm race — Race two ways of solving the same job as the problem grows.

Unit 14⚙️ Inside the CPU

The tiny instructions a computer really runs.

  1. Tiny instructions — A CPU can only do tiny steps, one after another.
  2. Assembly language — Readable names for machine instructions, plus memory with names.
  3. Loops from jumps — Compare, jump back, and repeat. That is all a loop is.

Unit 15🪜 Programming languages

Why we climb from bits up to Python.

  1. The language ladder — The same job written in bits, assembly, a C-like language and Python.
  2. Python, up at the top — See the assembly loop again in friendly Python.
  3. Maths in Python — Which keys to press for times, divide and powers, and why they look that way.

Unit 16🔁 Loops

Write Python to make a robot repeat itself.

  1. Meet the robot — Write your first program: step-by-step instructions for a robot.
  2. for loops — Repeat instructions without writing them again and again.
  3. Counting with loops — The loop variable counts for you.
  4. while loops — Keep going until something happens.

Unit 17🔀 Conditionals

Teach your programs to make decisions.

  1. True or false? — Computers decide things with questions that are True or False.
  2. if and else — Run some code only when something is True.
  3. The robot decides — Mix loops and ifs so the robot can react to its world.
  4. elif: more choices — Check one question after another.

Unit 18🧰 Functions

Make your own commands and reuse them.

  1. Name your steps — Make your own commands with def.
  2. Inputs — Give a function information to work with.
  3. Return values — Functions can work something out and hand the answer back.
  4. Build with functions — Combine small functions to solve a bigger puzzle.

Unit 19🥞 Stack & Heap

Peek inside memory while your program runs.

  1. The call stack — How the computer keeps track of which function is running.
  2. Every plate has its own variables — Variables made inside a function live on its plate — and vanish with it.
  3. The heap — Big things like lists live on the heap, and variables point to them.
  4. Stack overflow! — What happens when a function calls itself forever.

Unit 20🐛 Debugging

Be a bug detective: find and fix mistakes.

  1. Bugs are normal — Every programmer makes mistakes. Finding them is a skill.
  2. Read the error — Error messages tell you where to look and what went wrong.
  3. Off by one — The sneakiest bug: being out by exactly one.
  4. Fix the robot — Use Step to find exactly where things go wrong.

Unit 21🌐 How the Internet works

Addresses, packets, names and web requests.

  1. What is a network? — Computers join up and pass messages to each other.
  2. Packets — Big messages are chopped into small numbered packets.
  3. Names and addresses — DNS is the phone book that turns names into addresses.
  4. Clients, servers and requests — Your device asks, a server answers. That's HTTP.

Unit 22👥 Online games

Lag, and who decides what really happened.

  1. Lag — Messages take time to travel, so friends see you a moment later.
  2. The server decides — Why a game server checks moves instead of trusting players.

Unit 23🏗️ How apps are built

Front ends, back ends, APIs, databases and logins working together.

  1. What is an application? — An app is a team of programs, not one giant program.
  2. Front end, back end and APIs — Who talks to whom when you ask for your score.
  3. Databases — Tables of rows you can search, add to and change.
  4. Saving for later — Memory forgets when the program ends. Saved data stays.
  5. Logging in — How a server knows who you are.
  6. Putting an app together — Services call other services to get a big job done.

Unit 24🤖 How machines learn

Examples, digits, weights and neural networks.

  1. Rules or examples? — Some programs follow rules we write. Others learn from examples.
  2. Training, prediction and mistakes — Train on examples, predict new pictures, and fix mistakes with better data.
  3. Reading digits — How a network turns pixels into a guess about a number.
  4. Weights: the network's memory — Every connection has a number. Those numbers are what the network learned.
  5. Training vs. using — Training changes the model. Inference just uses it.

Unit 25💬 How chatbots work

Tokens, next-word prediction, attention and LLMs.

  1. Words become numbers — A language model reads tokens, and every token is a number.
  2. Predicting the next word — A chatbot writes by repeatedly guessing the most likely next token.
  3. Attention — Which words matter to which other words.
  4. Transformers and LLMs — Put it all together: tokens, attention, layers and next-token prediction.

Unit 26🧱 What makes a game

Players, goals, rules and feedback: the parts every game is built from.

  1. What makes a game? — Build a tiny game from parts and see what each part does.

Unit 27🔄 The game loop

How a game updates and redraws itself over and over.

  1. The game loop — Every game repeats the same few steps, many times a second.
  2. State — The state is everything the game remembers between ticks.

Unit 28📍 Coordinates and movement

Where things are in a game, and how they move.

  1. Where is everything? — Every spot on the screen has an x and a y.
  2. Velocity — Add the velocity to the position every tick, and things move.

Unit 29🕹️ Input and events

Keys, taps and the code that answers them.

  1. Events and handlers — Connect a key press to the code that runs when it happens.

Unit 30💥 Collision and physics

How games know things touched, and make them bounce and slide.

  1. Did they touch? — Collision detection asks two simple questions: across, and down.
  2. Gravity, bounce and friction — Three numbers change how a ball falls, bounces and slides.

Unit 31👾 Game characters that think

Rules, chasing and pathfinding for non-player characters.

  1. Teaching an NPC to think — A character's behaviour is just rules and algorithms running each tick.

Unit 32🎒 Inventories and game data

Dictionaries, item facts and how a game keeps its stuff.

  1. A bag of things — A dictionary keeps what you carry. A catalog keeps the facts about each item.

Unit 33🏁 Levels and progression

Difficulty curves, checkpoints and saving.

  1. Designing levels — Make a game that gets harder at the right speed, and save the player's progress.

Unit 34📡 Multiplayer problems

Lost messages, and keeping everyone's game in step.

  1. When updates get lost — Packet loss makes players disagree. The server fixes it by resending the truth.

Unit 35🏛️ Game architecture

A game is a set of systems, each with one job.

  1. Systems that work together — Split a game into parts with one job each, and connect them.

Unit 36🚀 Build your own game

Turn a big idea into a plan made of small systems.

  1. Plan your own game — Answer the big questions and list the systems your game needs.

Unit 37🧩 AI inside programs

AI is one part of a program. The program still owns the rules.

  1. Rules and AI content — Which jobs belong to the game's code, and which to an AI helper?

Unit 38📝 Prompts are specifications

How to say exactly what you want built.

  1. Saying what you want — A good request spells out the goal, rules and how you'll know it works.

Unit 39⌨️ Code completion

AI that finishes your code, and how to check it.

  1. Autocomplete — AI can finish your code. It's a good guess, not a guarantee.

Unit 40🛠️ Code generation

AI that writes whole functions, and why you still check them.

  1. AI writes a function — Describe a small job and AI writes the code. You decide if it's right.

Unit 41🔎 AI as teacher and debugger

Ask good questions, then check the answers.

  1. Asking AI for help — Good questions get useful explanations. You still decide what's right.

Unit 42🪓 Breaking software into parts

Turn "build a game" into pieces you can build and test.

  1. From "build a game" to a plan — Split a big idea into clear parts that you can build and test one by one.

Unit 43🌊 Vibe coding

Idea, request, build, run, diagnose, refine.

  1. The vibe coding loop — Direct an AI to build an app, test it, and keep refining.

Unit 44🤝 AI agents

AI that plans, edits, tests and tries again, with you in charge.

  1. How an AI agent works — An agent works in a loop on its own. A human decides the goal and reviews the result.

Unit 45🏗️ Building a project with AI

Plan, split, build part by part, and test, with an AI helper.

  1. A quiz game, start to finish — Use everything you've learned to plan and build a small project with AI help.

Unit 46✅ Testing and verification

How to know that code really works.

  1. Knowing it works — Tests turn "looks right" into evidence. Edge cases are where bugs hide.

Unit 47⚡ Circuits

Electricity needs a loop. Build circuits with batteries, wires, bulbs and switches.

  1. Make it glow — Electricity only flows round a complete loop: a circuit.
  2. Switches and buttons — A switch opens and closes a gap in the loop. Every button works this way.
  3. Short circuits — Electricity takes the easy way. A shortcut that skips everything is dangerous.
  4. One path or two? — Series and parallel: two ways to wire lights, and why gadgets use parallel.

Unit 48🔋 Volts, amps and ohms

Push, flow and squeeze: the numbers engineers use to design safe gadgets.

  1. Push and flow — Volts are the push, amps are the flow. Batteries in a row add their push.
  2. Squeezing the flow — Resistors squeeze the flow. Ohm's law: flow = push ÷ squeeze.
  3. Protect the LED — LEDs only work one way, and they need a resistor so they don't burn out.
  4. How long will it last? — Designers add up what every part uses to work out the battery life.

Unit 49🔀 Logic gates

Circuits that make decisions: AND, OR, NOT, and a circuit that adds.

  1. Switches that decide — Two switches in a row make AND. Side by side they make OR.
  2. Meet the gates — AND, OR and NOT: the logic gates inside every chip.
  3. Gates are game rules — Join gates together to build the rules of a game in hardware.
  4. A circuit that adds — Build a half adder: the gates a computer uses to add numbers.

Unit 50🧩 Transistors and chips

Switches flipped by electricity, gates and memory made from them, and what's inside a chip.

  1. A switch flipped by electricity — A transistor is a switch with no fingers: a tiny push on its gate turns it on.
  2. Gates made of transistors — Build NOT and AND from transistors, and every gate from NAND.
  3. Circuits that remember — Loop two gates together and they remember a bit. Loop one onto itself and you get a clock.
  4. What's inside a chip — From one transistor all the way up to your game console.

Unit 51🍞 From breadboard to chips

Build on a realistic breadboard: LEDs, transistors, pull-down resistors and real logic chips.

  1. Meet the breadboard — Which holes are joined inside a breadboard, and your first real-style circuit.
  2. Floating pins and pull-downs — A gate joined to nothing is floating. A pull-down resistor fixes it.
  3. A gate from transistors — Build an AND gate from two transistors, and count how many parts it takes.
  4. Lots of gates in one chip — A 74HC08 chip packs 4 AND gates into one part. Give it power, and wire it up.
  5. Build it for real — The parts to buy, how to stay safe, and a good order to build in.

Unit 52🕹️ Inputs and sensors

Buttons, dials, joysticks and sensors: how a gadget notices the world.

  1. Buttons and pins — A button joins a chip's pin to +, and a pull-down resistor stops it guessing.
  2. Dials and joysticks — A dial splits the battery's push, and the chip turns it into a number from 0 to 1023.
  3. Light, tilt and touch — Sensors turn light, tilting and touch into volts a chip can read.
  4. Analog vs digital — Some inputs are just on or off; others are a whole range. A threshold turns one into the other.

Unit 53🔊 Lights, sound and motion

LEDs, screens, speakers and rumble motors: how a gadget talks back.

  1. Screens are grids of lights — A screen is thousands of tiny lights, and each one mixes red, green and blue.
  2. Blinking fast to dim — A pin is only on or off, so to dim an LED the chip blinks it faster than your eyes can see.
  3. Speakers and frequency — Flip a pin on and off quickly and a speaker buzzes. More flips a second make a higher note.
  4. Motors and rumble — Motors turn electricity into spinning, PWM sets their speed, and a wobbly weight makes a controller rumble.

Unit 54🤖 Microcontrollers

A tiny computer with pins: code that reads buttons and lights LEDs.

  1. A tiny computer with pins — A microcontroller is a whole computer on one chip, with pins for its inputs and outputs.
  2. Blink an LED with code — Switch on, wait, switch off, wait: the first program almost every gadget maker writes.
  3. Read a button — read_pin() asks whether a button is pressed right now, so the program has to keep asking.
  4. Your first gadget program — Inputs, a program and outputs together: a quiz buzzer for two players.

Unit 55🎮 Design a gadget

Plan your own handheld game: requirements, a block diagram, a power budget, then test it.

  1. Requirements — Before building anything, write down what the gadget must do, in a way you can test.
  2. Block diagrams — Draw each part as a block, with arrows showing which way information flows.
  3. Power budgets — Add up what every part uses, then choose parts, brightness and a battery that meet the requirement.
  4. Prototype, test and improve — Build a rough version, test it with real players, and make it better, again and again.

Ready to start?

Grown-ups make a free account with just an email. Kids get their own profile with only a first name.

Sign up free