← All demo levels

Level 1 · Starter

Ten things you could build

All ten are running live on this page — touch them, drag them, type into them. Under each one is what it would actually take to build it.

The point of this page Every single one of these is plain HTML, CSS and JavaScript. No frameworks. Nothing downloaded. Nothing paid for. The whole page is three files, and you could read all of them in an afternoon.

Most of what looks impressive on the web is simpler than it appears. That's the lesson here.
1

Motion graphics

What it takes to build

Easy An afternoon CSS only — no JavaScript ~25 lines

How it works: you describe what a shape looks like at the start, the middle, and the end — then the browser invents every frame in between. You never draw the motion. You draw two or three moments and the browser fills the gap.

Here, three squares each follow the same circular path, just started at different times. As they travel they shrink and round into circles, then come back. The delay between them is what makes it feel choreographed rather than mechanical.

What to ask for:

Make three shapes orbit a centre point using CSS keyframes, each offset by a third of the loop, morphing from square to circle as they go.
2

Things that appear as you scroll

I appear when you reach me
So do I
Keep going
Each one waits its turn
Scroll back up — we reset
That's the whole trick

↑ scroll inside the box

What it takes to build

Easy An hour A little JavaScript ~12 lines

How it works: the browser has a built-in helper whose entire job is to tell you "this element just came into view." You hand it a list of things to watch, and it taps you on the shoulder when one becomes visible. You then add a class that fades it in.

People assume this needs a scroll-tracking library. It doesn't — that helper is free and built into every browser. This is roughly a dozen lines.

What to ask for:

Use IntersectionObserver to add a class to each card when it scrolls into view, and fade it up with a CSS transition.
3

A chart that draws itself

tap or hover a bar

What it takes to build

Easy An hour No chart library ~30 lines

How it works: each bar is an ordinary box. Its height is set to a percentage — 75% for 75. That's the entire chart. The growing animation happens because the boxes start at zero height, and CSS animates any change you make.

Charting libraries are big, and for simple bars you genuinely don't need one. When you have thirty thousand data points or want zooming, reach for a library. For six bars, this is less code than installing one would be.

What to ask for:

Build a bar chart from an array of values using plain divs, where the height is a percentage, and animate from zero on load. Show the value on hover and on tap.
4

Generative art

What it takes to build

Medium A day Canvas + JavaScript ~60 lines

How it works: a <canvas> is a blank rectangle you can draw on. Forty-six dots each have a position and a speed. Sixty times a second you wipe the rectangle, move every dot a little, and draw them again. Bounce them off the edges so they never leave.

The lines are the clever bit, and they're simpler than they look: check every pair of dots, and if two are close, draw a line between them — fainter the further apart they are. Nobody designed those constellations. They're a side effect.

What to ask for:

Canvas animation: 45 dots drifting with velocity, bouncing off edges, with lines drawn between any two dots closer than 80 pixels, fading with distance. Dots drift toward the cursor.
5

A card that tilts toward you

Move your cursor across me
— or drag a finger

What it takes to build

Easy An hour A few lines of JavaScript ~10 lines

How it works: you ask where the cursor is inside the card — left edge or right, top or bottom — and turn that into a rotation. Cursor on the right, tilt right. It's one calculation, run whenever the pointer moves.

The 3D comes free: browsers can rotate any element in three dimensions with a single CSS property. You're not building a 3D engine, you're feeding two numbers into one that already exists.

What to ask for:

Tilt a card in 3D following the pointer, using perspective and rotateX/rotateY, and reset smoothly when the pointer leaves. Make it work with touch too.
6

Search that answers as you type

    What it takes to build

    Easy Half an hour No database needed ~15 lines

    How it works: every time a key is pressed, go through your list and keep only the items containing what's been typed. Redraw the list. That's it — no search engine, no server, no waiting.

    It feels instant because nothing leaves your computer. The whole list is already here. This works beautifully up to a few thousand items; past that you'd start asking a server, which is where Section 4 comes in.

    What to ask for:

    Filter a list of items as the user types, case-insensitive, matching anywhere in the word, with a friendly message when nothing matches.
    7

    Before and after

    BEFORE
    AFTER

    What it takes to build

    Easy An hour Real images work the same way ~20 lines

    How it works: two pictures stacked exactly on top of each other. The top one gets trimmed — "only show the leftmost 40% of me" — and dragging changes that number. The bottom one was always fully there; you're just uncovering it.

    Nothing is being blended or generated. It's a sheet of paper sliding across another sheet. Once you see it that way it stops being mysterious.

    What to ask for:

    Before/after image comparison slider using clip-path inset, dragging with pointer events so it works on touch as well as mouse.
    8

    Drag to reorder

    • Pick up any of us
    • Drag me somewhere else
    • We shuffle out of the way
    • Works with a finger too

    What it takes to build

    Medium A day Fiddlier than it looks ~35 lines

    How it works: when you press on an item, remember it. As you move, look at the others and ask "have I gone past the middle of that one?" If yes, move the dragged item in front of it. The list reorders continuously while you drag, so the gap is always where you'd expect.

    This is the first genuinely fiddly one. Not because any single part is hard, but because touch and mouse behave differently, and you have to stop the page scrolling while someone drags. Worth knowing which things are secretly fiddly — this is one.

    What to ask for:

    Drag-to-reorder list with pointer events, swapping when the drag passes the midpoint of a neighbour. Must work on touch — remember touch-action so the page doesn't scroll mid-drag.
    9

    Celebration

    What it takes to build

    Medium A few hours Basic physics ~45 lines

    How it works: on the click, make ninety small rectangles at the button, each fired off in a random direction at a random speed. Then, sixty times a second, nudge every one downward a little more than last time. That single line is gravity. Genuinely — adding a small amount to the downward speed each frame is what makes things fall.

    Add a slow spin, fade them out, and delete them once they're invisible so your page doesn't accumulate thousands of forgotten rectangles. That cleanup is the part people forget.

    What to ask for:

    Canvas confetti burst on click: 90 rectangles, random direction and speed, gravity added each frame, rotation and fade, removed once fully transparent.
    10

    Text that assembles itself

    YOU CAN BUILD THIS

    What it takes to build

    Medium A few hours Pure text, no graphics ~40 lines

    How it works: every letter gets a random moment to start scrambling and a random moment to settle. Until its start, it shows the old letter. In between, it flickers through junk symbols. After its end, it shows the new letter and stops.

    Because each letter has different timings, the phrase resolves raggedly instead of all at once — and that raggedness is the entire effect. Give every letter identical timing and it looks cheap immediately.

    What to ask for:

    Text scramble effect cycling through phrases: each character gets a random start and end frame, shows random symbols in between, then settles into the final letter.

    What all ten have in common

    None of them needed a framework. None needed a paid service. None needed anything downloaded. The entire page — all ten demos — is three files: one for structure, one for looks, one for behaviour.

    The honest summary The hardest one here took a day. Most took an hour.

    What makes real projects hard is rarely any single effect — it's a hundred small decisions stacked up, and keeping them consistent as things grow. Which is exactly why Section 3 exists.

    Things to try

    1. Change a number. Open demos.js, find 46 in the particles demo, make it 200. Reload. That's the whole loop of building things.
    2. Steal one. Pick your favourite, give your AI the "what to ask for" line, and build it in an empty folder. It's the fastest way to see how little code these are.
    3. Break one on purpose. Delete the gravity line from the confetti and watch it fly off forever. Understanding usually arrives by breaking, not by reading.
    4. Combine two. Confetti when the search finds exactly one result. Nobody asked for it. That's the fun part.
    5. Guess before you look. Pick a demo, write down how you think it works, then read the code. Being wrong is how you find out what you didn't know.