Some of the best computer science lessons never touch a keyboard. That sounds backward until you’ve taught the subject for a while and watched a student who “can’t code” turn out to just not understand what an algorithm is yet. Take the computers away and that gap gets easier to close, not harder, because nobody can hide behind the syntax.
Unplugged activities are the screen-free version of computer science: paper, bodies, cards, beads. They teach the actual ideas (sequencing, logic, encoding, sorting) without a single line of code in the way. This post is a bank of concrete ones you can pull from for a no-device day, a sub plan, or the stretch before students are ready for real syntax. It’s the deeper cut promised in How to Teach High School Technology, and it pairs with the first-week openers in First Day & First Week of CS Class Activities.
Why teach computer science without computers?
Because the thinking comes before the typing, and most students who struggle with code are actually struggling with the thinking.
A few situations where unplugged earns its keep:
- No-device days. The cart is double-booked, the wifi is down, the platform is doing “scheduled maintenance” at the worst possible moment. An unplugged activity is a real lesson, not a time-filler, so a bad-tech day doesn’t become a wasted day.
- Sub days. A guest teacher cannot troubleshoot thirty logins, but they can hand out a logic puzzle and read directions for a sorting game. Unplugged activities are some of the only CS lessons that survive a substitute.
- Building intuition before syntax. This is the real reason. A student who can break a task into exact, ordered steps will pick up Python or JavaScript later. A student who can’t will fight the syntax forever, because the syntax was never the problem. Unplugged teaches that core skill to everyone at once, the kid who’s been coding since middle school and the kid who signed up because it fit their schedule.
The bonus: these activities are nearly impossible to fail, which gets your nervous students in the door before the stakes go up.
Unplugged activities for core CS concepts
Pick based on the concept you’re after. Each of these needs almost nothing (paper, markers, cards, a little floor space) and each teaches a real idea, not a craft project that happens to look computery.
Write the algorithm for a sandwich (algorithms). Students write step-by-step instructions for making a peanut butter sandwich, then you follow them literally. “Put the peanut butter on the bread” gets you a hand mashing a closed jar against an unopened loaf. They rewrite, more precisely, until it works. The lesson lands without a lecture: computers do exactly what you say, not what you mean. (Pantomime works fine. No food, no mess.)
Human sorting networks (sorting). Tape a sorting-network diagram on the floor (CS Unplugged has the layouts) and give each student a number card. They walk the lines, and at every node the two students who meet compare cards, the smaller taking one path and the larger the other. They come out the far end in sorted order every time, having run a sorting algorithm with their feet.
Binary-number bracelets (binary, encoding). Give students a key (A equals 01000001, and so on) and have them spell their initials in binary, then string a bracelet of two bead colors to match. They walk out having encoded information the exact way a machine does, and they’ve got something to take home, which never hurts.
The paper function machine (functions). Fold a paper “machine” with an in-slot, an out-slot, and a hidden rule inside (“double it and add one”). Students feed in numbers, you hand back outputs, and they reverse-engineer the rule from the pairs. It teaches input, output, and the idea that a function is a reliable little box that does one job.
The maze-directions debugging game (debugging). Draw a grid maze and have one student write a list of moves (“up, up, right, down”) to get a token from start to finish. A partner runs the list exactly and marks where it crashes into a wall. The writer finds the broken step and fixes only that step. Students feel, directly, that a bug is usually one wrong line in otherwise fine logic.
Be the network (networks, packets). Each student is a “node.” A message gets broken into numbered slips of paper (packets) that travel hand to hand across the room to a target student, who reassembles them in order. Pull one student out (a downed router) and make the packets find another path. They learn routing, packets, and why order and delivery matter, without a cable in sight.
The conditional-logic card game (conditionals). Deal cards and post a rule on the board: “IF your card is red AND even, stand up; ELSE stay seated.” Run rounds, escalating the conditions (add OR, add NOT, nest them). Students become the program evaluating the condition, and the abstract if/else they’ll meet in code is muscle memory before they see it on screen.
The pseudocode dance (loops). Choreograph a short dance as written pseudocode: “REPEAT 4 times: step left, clap.” Students perform exactly what’s written, no improvising, and you tweak the loop count or nest a loop inside a loop to change the routine. They feel a loop as repetition with a counter, and feel why an off-by-one error matters when the dance ends facing the wrong way.
The human-robot directions game (sequencing). One student is the “robot” and moves only on explicit commands: “step forward,” “turn right ninety degrees,” “stop.” A partner navigates them across the room using only those commands, no “go over there.” Add an obstacle. It’s loud and funny and it’s secretly a lesson on why ambiguity breaks a program.
How do you make unplugged feel rigorous, not like filler?
This is the fair worry, because unplugged done lazily does feel like a craft hour. The difference is in three moves.
Name the concept out loud, before and after. Don’t run the sandwich game as a fun thing on the schedule. Tell them it’s about algorithms, run it, then debrief: “What made our instructions fail? That’s exactly what happens to your code.” The activity is the hook, but the naming makes it stick.
Connect it forward. Every activity should have an “and next week, when you see this in code” attached. The conditional card game is if/else. The dance is a for loop. When students hit the real syntax later, you say “this is the dance,” and the abstract thing is suddenly familiar.
Assess the thinking, not the craft. Collect the rewritten sandwich algorithm. Have students explain why their maze fix worked. Ask them to write the rule the function machine was using. You’re grading reasoning, the same thing you’ll grade once they’re coding, so it isn’t a day off from rigor. It’s the same rigor with the syntax stripped away.
Done that way, an unplugged day is often where the real understanding happens, and the coding later is just where they apply it.
Free unplugged resources
You do not have to invent these from scratch, and two free libraries cover most of what you’ll want.
- CS Unplugged (csunplugged.org), from the University of Canterbury in New Zealand, is the original: a free collection of activities that teach computer science through games and puzzles with cards, string, and crayons. The sorting networks, binary, and image-representation activities are all there with printable materials.
- Code.org weaves free unplugged lessons through its CS courses (CS Fundamentals and CSP in particular), so you can find a screen-free lesson that maps to a standard you’re already teaching. They’re built to slot into a real scope and sequence, not stand alone as one-offs.
Between those two, you can build a week of unplugged lessons without paying for anything.
For a few no-prep, ready-to-print versions (so you’re not formatting card decks the night before), the Free Library has unplugged openers that drop straight into a CS class, including a ready-made unplugged CS activity cards set. And when it’s time for these ideas to meet real syntax, the Algorithms and Programming unit of our editable AP Computer Science Principles curriculum is where the sorting games, conditional card rounds, and loop dances become working code.
Once devices are working and students are ready to apply all this, Coding Activities for Beginners picks up where the unplugged work leaves off.
Frequently asked questions
What are unplugged computer science activities? They’re CS lessons taught without computers, using paper, cards, bodies, and simple props to teach the underlying ideas (algorithms, binary, loops, sorting, networks, debugging). The goal is to build the thinking that coding requires before adding the syntax.
Are unplugged activities only for younger students? No. The props look simple, but the concepts scale: a human sorting network, a packet-routing game, or a nested-loop dance challenges high schoolers just fine. Pitch the debrief at their level and add complexity (nested conditions, multi-path networks) to keep it rigorous.
Where can I find free unplugged lessons? CS Unplugged (csunplugged.org) and Code.org both offer free, printable screen-free lessons. CS Unplugged is a dedicated bank of activities; Code.org weaves unplugged lessons through its standards-aligned courses.
How do I keep unplugged from feeling like filler? Name the concept before and after, connect each activity forward to the code students will write later, and assess the reasoning (collect the algorithm, ask for the fix, grade the explanation). Rigor lives in the debrief, not the props.
Can a teacher with no coding background run these activities? Yes, and they are one of the best places to start. Because there is no syntax to debug, an out-of-field teacher can run a sorting network or a conditional card game on day one with confidence. The wider plan for teaching CS without a coding background is in Teaching Computer Science With No Coding Background.
What unplugged activity is best for the first week of class? The sandwich algorithm and the human-robot directions game both land fast, need no prep, and survive the first-week login chaos. They get nervous students participating before any device is involved. For a fuller week-one sequence, see First Day & First Week of CS Class Activities.
