ToonTalk 3D

The basics

Moving around

Drag with the left mouse button held to orbit the camera around the workshop; scroll to zoom in and out (numbers show more digits and more of their faces up close); drag with the right button to slide sideways. On a touchpad: one-finger drag orbits, pinch zooms, two-finger drag slides. Not sure? Press Look around in Marty's panel, or ask him "how do I look around": he turns, zooms and slides the camera himself and tells you what your mouse or fingers do to get the same. Lost? The ⌂ home view button on the bar (or the Home key) puts the camera back where it starts — the whole table, or the whole yard — out of any close-up first. The smart camera (a toggle in the ⋮ menu, on by default) comes in on what a robot works on during a lesson or a run — in a lesson, point at the side of the screen to lean back out — and, when Ruby or Dusty is awake, on a thought bubble you point at, and after a lesson or a refusal it pulls back to show the robot and its thought; it comes back when you point away. While a robot runs it watches from well above the bench, where the holes of the boxes on the desk are open to view instead of hidden behind their near walls, and close enough that the box being worked on is a good part of the picture however wide your screen — a wide one comes in nearer rather than showing more workshop. It keeps what is near the work in the picture: a robot away at a stack is watched where it stands rather than from far enough back to hold the desk as well. Pointing at the side of the picture leans it back out, but not while a robot runs — reading Marty's card or the robot's actions takes the pointer out of the picture, and watching is not reaching. When a message names Ruby, Mimi, a stack, the notebook or the judge, it pulls back until that is in view. Waking Ruby brings it in on the thought, and so does a robot having her loosen one mid-run — the camera goes back to the work when she is done; an erasure that sets the robot running sends it out to watch. It never moves while your mouse is moving, only a moment after it rests, and your own orbiting or zooming always wins: the follow lets go until the next occasion. The same gestures work on a touch screen. ⛶ at the end of the bottom row is worth pressing first on a tablet — it wins back the height the browser's own bars take, and asks to stay landscape while you are in it.

Handling things

You do everything with single clicks: click a thing to pick it up, and it follows your pointer; click where you want it to set it down. While you carry something, the tooltip's first line says what letting go here will do — rides on this, joins this on the right, goes inside the room, × 5 on the number — before it happens (Drop hints, a switch in the ⋮ menu). The row of dark pedestals in a semicircle behind the robot's work area are stacks — endless supplies of numbers, pads, boxes, scales, nests, rooms and little robots. Click a stack to take the top one.

The wooden table in front is your workbench. Robots can never reach it — that is the point: what you build there is yours until you hand it over.

While a robot is working

The table stays yours. A running robot has its own hands — you can see what it is carrying in its claw — so you can go on picking things up, putting them down, joining them, taking from the stacks and turning notebook pages while it works away behind the desk. What is refused is its own area: its desk, its work spots, the copier, its thought bubble, and giving anything to another robot or setting one going. Point at one of those mid-run and it says so.

Anything you pick up remembers where it came from. The ↩ button on the holding card (or Ctrl+B) puts it back exactly there — the spot on the table, or the hole in the box. Aiming at the gap it left does not work and never could: with the thing gone, the same point on the screen is somewhere further back.

On a screen you touch

A finger is not a pointer: it is only anywhere at all while it is touching, and while it is touching it covers the very thing it is over. So on a touch screen what you are carrying does not follow your finger — it waits at one spot, left of centre and a little low, where you can always see it. Tap where you want it and it goes there, exactly as a click does. Or put your finger on the thing itself and drag: it follows, and goes where you lift your finger. Turning the camera turns the thing in your hand rather than carrying it off the screen.

Typing works there too, though nothing on the screen looks like a place to type: the ⌨ button on the holding card raises your keyboard, and what you type goes onto the thing in your hand — digits onto a number, letters onto a pad or a name plaque, just as a real keyboard would. Press it again, or put the thing down, and the keyboard goes away. A tablet's keyboard offers the real symbols where a typewriter offered stand-ins, so on a number × multiplies, ÷ divides and a proper minus sign negates, exactly as *, / and - do.

Your first project: a robot that counts

Ten minutes, and it meets everything that matters. You will teach a robot one step, watch it stop, and loosen its thought so it never stops. The workshop can walk you through it: ⋮ → The first project says each step as the one before is done, with a ring of light on the thing to reach for.

1. Click the number stack (the pedestal of 1s behind the table) and set the 1 down on the table.
2. Click the robot stack and set a little robot down on the table.
3. Pick up the 1 and drop it on the robot. The robot grows, steps behind its desk, and its thought bubble opens with the 1 in it: you are teaching it, and everything you make it do now is a step it remembers.
4. In the bubble, click the number stack: the robot takes a fresh 1 in its claw. Now click the 1 it was given: the robot drops the new 1 on it, and 1 + 1 = 2.
5. Press Leave thought bubble. The daydream rewinds — the 2 is a 1 again — and the robot keeps the lesson: take a 1, add it to what I was given.
6. Press Run what it learned. It does the step once and stops: Ran 1×. Its thought says it is waiting for a 1, and what it holds is now a 2, so the thought no longer fits.
7. Wake Ruby the eraser (click her, beside the copier) and click the 1 in the thought bubble. It becomes any number.
8. Press Run again (a loosening never sets it going by itself, so you can erase several things before it runs). It counts: 3, 4, 5… as long as what it holds is a number, which is always. Pause holds it still.

That is the whole language in one robot: a lesson is a thing shown once, a thought is the shape it waits for, and Ruby turns one example into a rule. Everything below is more things to show it.

A robot that teaches a robot. In a lesson, have the robot pick up a box and click a little robot among its things: that is the step teach. The little robot — the pupil — steps up to a desk of its own beside the teacher with the box on it, and everything you do next is the pupil's lesson: its thought bubble is the one shown, and the teacher keeps each step too, as a taught step. Ruby on the pupil's thought is taught as well. Press Stop teaching it when the pupil has learned enough, and the teacher's own lesson goes on. Leaving the teacher's thought bubble takes the pupil's lesson back with the rest of the daydream. Run, the teacher does all of it for real: the pupil steps up, performs each taught step in front of you, and stands trained at its desk with its box. Click it and press Start. A robot may teach a robot, not a robot that teaches a robot. examples/meta/🎓 teacher is a robot that teaches a little robot to count with the 1 it gives it.

Dusty on the pupil's thought is taught too. Ruby's loosening of a part of the pupil's thought is a taught step, and so is Dusty taking a part out — anything, or nothing, fits there — which is what a robot needs when a token may be in either of two holes. A pupil whose lesson is over stands half size at its desk, so the teacher and the taught are told apart at a glance; it is full size while it learns and while it works.

The little robots it taught stay among its things. After Stop teaching it, the pupil at its own desk is still within the teacher's reach: click the pupil with an empty claw and the teacher picks it up (the step is pick up the first little robot it taught); click the box on the pupil's desk and it takes that. A robot can thus train two robots and set them, with a box, on a thing's panel: examples/meta/🎓 timer-teacher teaches Ask and Tell one after the other, takes a number's panel out onto a work spot, puts Tell's box, Ask and Tell on it, and folds it away — the number is a stopwatch. A desk left aside with a box on it holds the workshop's panels still, so a tidy teacher puts a leftover box back in its hole.

Pads speak. Read on the held card reads a pad in full and aloud, in the workshop's own voice. In a lesson, Read is a step: the robot reads out the pad in its claw when it runs, and waits for its own words. And [speak] given to a pad's bird has the pad speak.

The card, and a note on the robot. The Trained actions card at the top right lists the steps of the robot at the desk — or of a robot in your hand, the moment you pick one up, a member at a time if it leads a team (click the line under the title for the next). Under that line is a place for a note: click it and write what the robot is for, in your own words. The note is the robot's, and goes with it into a saved world, a saved thing and every copy; Marty reads it back when you ask what a robot does. Every robot in the examples carries one, so picking up a stranger tells you what it does before you read its steps; the tooltip over a robot carries it too. With Marty's commentary on, the robot sets off at once and his opening line — what it is trying to achieve — is read while it works. The button under the table says Run what it learned for a robot you have just taught, and Start the robot for one that arrived trained.

Numbers

Numbers come off their stack as 1s. While holding one, type digits and they go on the end — a 1 typed 2 is 12, and Backspace takes the last digit off, so 12 backspaced twice and typed 7 is 7 — - to make it negative, and * / ^ to choose what it does when dropped on another number (adding is the default — and adding a negative is subtraction). Dropping a number on a number combines them: the arriving one applies its operation. Division gives exact fractions, never rounded decimals.

A number block shows its value on the front and top; walk the camera close and the other faces show the same value in English words, scientific notation, and decimal form — with a bar over a repeating part when it fits. Fractions get words too: 1/6 reads one sixth, 3/4 three quarters, 7/2 seven halves.

Two operations have names rather than signs, because nothing says an operation has to be one character. Type mod on a held number and it will leave what is left over — 17 dropped on… rather, drop a mod 5 on 17 and 2 remains. Type set and it simply replaces whatever it lands on. The letters need not be typed cleanly: as soon as the last few you typed spell a name, the number takes it.

Pads

Pads are paper for words. Type on a held pad to write (Shift+Enter for a new line; Enter on its own looks at the pad close up, where Enter writes new lines and Ctrl+Enter or Escape comes back; Ctrl+V pastes). Drop one pad on the left edge of another and it reads first; on the right edge and it reads last — "Talk" dropped on the right of "Toon" makes "ToonTalk". Dropped in the middle of another it rides on it, part of its scene (see Behaviours).

Typing on a pad adds to what it says, and that is what a robot shown it remembers — not the words it ended up with. Train one on a blank pad by typing "Ken " and it goes on adding "Ken " each round: "Ken Ken Ken ". A robot shown something that was not a plain addition — letters rubbed out with Backspace, say — remembers the words instead.

The other way round picks letters out: drop a pad on a whole number and that number chooses a letter — "Talk" dropped on a 2 leaves a pad reading "a". The number is spent saying which letter you meant.

A number dropped on a pad rides on it, the way a pad dropped in the middle of another does: a score across a field, a count beside a picture. Move the pad and the number goes with it; a robot can change it where it sits. A riding number shows its value and nothing else — no operation badge and no frame — and is kept inside the edges of the pad it is on.

Pictures

A pad's face can carry a picture as well as words. Drag an image file on to the page and it lands as a pad where you dropped it; drop it on a pad that is already there and the picture covers that pad instead. A picture pad is a pad in every other way — it copies, files in the notebook, goes in a box, joins other pads, and Dusty takes it away. Hold one and press Ctrl with the arrow keys to make it bigger or smaller; a picture keeps its own proportions rather than being squeezed into the tablet's.

The words and the picture live on the one pad, so a caption is not a second thing — and a robot's thought compares both. A robot trained on a particular picture wakes for that picture and no other, which is how the naming example works.

To caption a picture, hold it and type. Words written over a picture are drawn on a band across the foot of it so they can be read against whatever is behind them — that is where the labels in the album example come from. Backspace rubs the caption out again.

That band is a shortcut, not the only way. A label is an ordinary pad that has been told what to look like — grey paper, white writing, wide and short — and dropped in the middle of a picture, where it rides. See what a thing looks like: because it is data, a robot can be trained to make one.

What a thing looks like

How a pad or a number is painted is data, so it can be set, so a robot can set it. Send the thing's own bird a box:

A pad’s words are data the same way, so a robot on the back of a label can rewrite it: a die rolled each round, a box of colour names, and [set | text | pad] is a label that changes its mind.

Every whole number says itself in English on one of its faces, however big it is: “one hundred twenty-three billion four hundred fifty-six million…”. The names are built the way English builds them, out of Latin numerals, so they go on well past the ones in dictionaries — a one with three hundred and three noughts is one centillion. Past even those it reads itself as about five point seven times ten to the power of sixty-nine, which is still something you can say out loud. When a number is too long to write out on one face you get the beginning and the end of it, with the middle closing up, never just the beginning.

Read on the card while you hold a pad puts its words on the card in full — and reads them aloud, if Marty’s voice is on.

A made thing can be tipped as well as turned: hold it and the up and down arrows lay it on its back or stand it on its nose, the same as they turn a number to its other faces.

Ctrl+C copies the face you are reading off a number in your hand — the digits, the grouped form, the words or the scientific one, whichever you have turned toward you. And a cube you have turned stays turned when you put it down.

Any colour the browser knows by name works, and so does a #rrggbb of your own. A number takes background, colour and font; its size is its own. Every one of these is a real box on a page of the thing's info notebook (the ⓘ on its panel): take one out, write a different word on its last pad, and give it to the bird. The ⓘ hands the notebook to you and then changes to a return arrow — press it again and the notebook goes back where it came from, from wherever on the table it had got to.

So a grey label with white writing is four messages, and a robot shown those four messages can make one for every picture it meets.

A pad on a pad

Drop a pad on the middle of another pad and it rides there: move the big one and the small one goes along, keeping its place on the face. A pad riding on another is flat — a picture painted on the field rather than a card lying on it — and if it carries a picture and no words it keeps only the picture, transparent wherever the picture is. That is what makes one usable as the ball in a game.

Sounds

A sound is a little speaker lying face-up on the table — a walnut cabinet with a black baffle, a woofer, a tweeter, and a screen showing the waveform it holds. It arrives silent: a flat line.

Making one. Drop a [frequency, seconds, shape] box on a sound and it sings: the number is hertz, the fraction is how long, the pad is one of sine, square, sawtooth or triangle (anything else reads as sine). Or drag an audio file on to the page — .wav, .mp3, .ogg, .m4a, .flac, .aac — and the recording arrives on a speaker of its own.

Remaking one. A sound answers × and set, and refuses + — adding to a sound has no meaning. A ×2 dropped on it plays it twice as fast, a ×½ stretches it, and a ×−1 plays it backwards: the same minus sign that makes a number subtract, on a thing whose axis happens to be time.

Joining them. Drop a sound on another sound's edge and they play one after the other — the same gesture that joins two pads into a word. A recording and a made tone join just as happily.

Turning things on and off

Press Space to turn on whatever is in your hand, or whatever the pointer is over; press . to stop it. A sound plays and stops; a house or a panel sets its robot working and stops it; while a robot is running at the bench, . is the Stop button — the robot finishes the round it is in. (Space still types a space while you are writing on a pad.) Picking a sound up does not play it.

Naming a thing

Hold a box, a bird, a nest, a house, a scale, a sound or a notebook and type: the letters become a name on a little plaque. Backspace rubs it out, and rubbing out the last letter takes the plaque away. A plaque is never wider than the thing it belongs to, so a row of named things in a box stays readable rather than overlapping.

Boxes and scales

Boxes have holes, and holes hold anything — numbers, pads, nests, other boxes, even little robots (they lie down inside). Type a digit while holding a box to give it that many holes; type 0 and you have an empty box, which joins onto another box without changing it. Boxes are arrays: drop a box on a box to join them — drop it on the left side and its holes go on the left, on the right side and they go on the right — and shrinking a box splits the extra holes off as a box of their own.

Drop a box on a whole number and it splits there: a box of five dropped on a 2 becomes a box of the first two and a box of the rest. That, with an empty box for the end, is how a robot walks along an array. On a robot’s desk the first half stands where the number was and the rest on the next work spot to its right. A box also says how many holes it has: [query | holes | bird] to a bird to the box answers with the number.

Scales have two pans that work exactly like holes; the beam tips toward the larger number. A drop on the scale itself lands in the pan on that side, and a pan with something in it takes the drop onto that thing. A badge number weighs what it does: ×2 balances ÷½, +3 balances −(−3), and an operation against a plain number leaves the beam undecided. A robot trained on a scale that is saying something remembers the tilt, not the numbers: its thought reads "a scale tipping left", and it fires on any pair that leans that way — which is how a robot chooses between two paths.

A box with no holes is a mould. Drop a written pad onto one and it takes the word apart, one letter to a hole; drop a robot team on one and it comes apart, one robot to a hole (drop them on each other to make a team again); and pour a box of letters onto a blank pad to get the word back. A box that has holes is a container rather than a mould — dropping a robot into a hole is how a program carries a spare team — so the two never get in each other's way.

A scale weighs words as well as numbers: the one later in the alphabet is the heavier, and case is not weight, so "Apple" and "apple" balance.

Dice

Dice are where chance comes from. A die does not show a rolled number of its own — it re-rolls the number it lands on: drop a die on a 1 and the 1 becomes anything from 1 to 6, and the die is spent in the throw, like any pad you drop. To change the range, hold a die and type: type 20 and you have a twenty-sided one, and it says so on its faces.

Robots take dice from the stack exactly as you do, so "throw a die into hole 2" is an ordinary step. A team whose members expect different rolled numbers is a program that branches on chance — that is all the sentence factory does.

Birds and nests

Take a nest from its stack and set it down: the egg hatches into a bird — they are a pair for life. Give the bird anything and she flies it home to her nest, tucking new deliveries under the pile so the top is always the oldest. Click the top of a pile to take one delivery; grab the tower lower down and you pick up the whole nest, deliveries and all.

Copy a bird on the copier and both birds serve the same nest. Copy a nest and you have a broadcast: give any of their birds something and every copy of the nest receives its own copy at once.

Two nests dropped together become one. The pile of the nest you are holding joins the pile below it, and the survivor answers to both names — so every bird of either nest goes on delivering, to here. That is how you rewire a program that is already running.

A nest is a window, not a wall. A robot shown its job on a plain number will do the same job when it is handed a nest with a number on it: it recognises what is on top, and it reaches through to the delivery rather than carrying the whole nest off. A robot shown the job on a nest in the first place means the nest — which is how a robot can pick nests up and swap them about. It does again exactly what it was shown.

Robots

Take a mini robot from its stack, set it on the table, and drop something on it: it grows, steps behind the bench, and its thought bubble opens — you are now teaching it. Everything you make it do (take things, drop them, fetch from stacks, use the copier) is remembered as steps about its own things — "hole 1 of what it was given", never places in your world. Leave the bubble and the daydream rewinds; the robot keeps the lesson.

Its thought bubble shows the condition: the shape it must be given before it will run. Give a trained robot something that fits and it gets to work at once, repeating while the condition still matches — a finite job ends itself, because at the end the condition stops fitting or the robot dozes on an empty nest. The bar’s Pause button holds every robot still, mid-stride, and Run carries on exactly from there. Drop one trained robot on another to form a team: the members line up on the floor behind the leader, each with its own small thought over its head, and whichever one recognises what the team was given walks up to the desk and does the work while the others wait their turn.

A team stands in a queue — the leader at the front, the rest lined up behind it, on the table as well as at the desk. Nothing is hidden. Whatever you hand to a member is handed to the leader: a team has one leader and one work surface. Click a member to take it out of the team; set it down and it is a robot of its own again, or drop it on another robot to join that one. Drop a robot on the leader to add it to the end. Picking the leader up picks up the whole team.

How a robot says it is finished. A robot that vacuums away the very box it was working on has ended the team for good — there is nothing left for any thought to match, and the message says so rather than suggesting you erase anything. It is worth doing deliberately at the end of a program. A house whose robot has done that is a house with nobody working and nothing to work on, so it folds away to nothing, taking whatever is left inside with it. That is how a recursive program clears up after itself.

A robot in a thought bubble means that robot: one with the same name and the same lesson. Erase it with Ruby and it becomes "a robot — any one", and again "anything".

Typing on a number a robot is holding is remembered two ways, and the difference matters. Type digits and the robot remembers that exact number. Type only an operation — -, * and so on — and it remembers "make it subtract", which then works on whatever number it is handed. That is how one robot can take away 30 today and 7 tomorrow.

Click the bubble of a robot (big or mini) to take out a copy of the very thing it was first shown. Type while holding a robot to name it — the name appears on its chest. To save a robot, hold it and press Save held thing.

A robot can take out a panel. In a lesson, with something in the robot's claw, press ⚙ and that thing's panel comes out onto a free work spot. The robot can then take the panel and drop it on another thing's panel — a panel dropped on a panel nests whole, and the behaviour inside works on that thing. That is how to train a robot that gives things a behaviour. (Dropping the behaviour pad itself on a thing binds it in one step; the panel route groups behaviours inside a thing's own panel.) The robot can also drop a behaviour's panel straight onto a thing sitting in a hole of what it was given: the behaviour binds to that thing, and the tray lands on a work spot. A panel does not go in an empty hole, in a lesson or by hand — put the thing itself in, or drop the panel on a thing. The knob is a step too: in a lesson, the knob on a panel standing on a work spot records "put away the panel on that spot, back inside its thing", and the robot does it in a run wherever the thing is by then. A panel dropped on a panel goes in as its card: the tray folds into the card first, and the card stands on the host's floor with its sentence readable.

Reading a thing's back. Point at anything and press ⚙ with an empty hand: its panel comes out. On a panel that groups behaviours, the cards stand magnified on its floor, like the gadgets on the back of one of the original ToonTalk's pictures; press Enter while pointing at the panel and the camera looks straight down at it, framed like a page. Point at a card there and press ⚙ again: the card's own panel comes out beside, its robot at the box it works on, and Enter there looks from the front. The knob folds each one home. With a behaviour in your hand, SPACE sets it down where your hand is and switches it on, and “.” sets it down and rests it — a behaviour works from the ground, never from a hand, and the key does not go into its name. A panel always comes out of its thing and folds back into it — a working one, brought back out with ⚙, grows from the thing (or from your hand) the same way, and on the grass it is set down beside the thing rather than in the table’s tray row. The ⓘ notebook comes out of its plaque and goes back into it. Closeups nest: in a closeup of a panel, ⚙ over a card takes you on into the card's panel, and the knob or Escape brings you back to the panel it stands on; only the last Escape reaches the workshop. Enter works with something in your hand too. examples/games/👾 space-invaders is built to be read this way.

Projects. The ⋮ menu’s Projects… walks four small projects step by step here in the workshop — a robot that counts, a box of two numbers, a bird and her nest, a robot on a box — with a ring of light on the thing to reach for next and a glow on the button to press. Nothing is done for you; finishing one offers the others. Settings… in the same menu gathers the switches — sound, voices, hints, the camera, how much Marty helps — and opens once for a new name.

The little desks beside the robot are its work spots — its own scratch space, cleared onto the table when it finishes, so nothing left there is ever lost. They read left to right, spot 1 at the left of each row. A spot sizes what you set on it the way a hole does: something too wide, a box of eight holes say, sits there smaller rather than hanging over its neighbours, and comes back to full size the moment it is picked up. A robot shown setting something down on an empty spot uses the next free spot when that one is taken — a house-maker's copies stand in a row rather than going inside the first house — while a drop onto what already stands on a spot combines with it, exactly as it did when you showed it.

You need not keep the difference between the stand and the work spots in your head while you work. If a round leaves the stand empty — because you carried the robot's own thing off it and combined it with something on a spot — whatever is on the spot comes back to the stand at the end of the round, and the next round finds it there. A robot has only really finished when its stand is empty and it has nothing to show for it, which happens when it vacuums its own box away on purpose.

How a team takes turns

Drop one trained robot on another and they form a team. Whatever you hand a member is handed to the leader, and each round the team is tried in order: a robot steps up, its thought appears over its head, and if what it is holding does not fit, the parts that do not fit turn red, it shakes its head, and it goes to the back of the queue while the next one tries. The first one whose thought fits does the work. If none of them fits they all queue up and the run stops, with the leader's thought back over the leader and its red parts showing — something Ruby can loosen.

One rule follows from the queue: the first robot to doze stops the team. A robot facing a bare nest waits, and the team waits with it rather than stepping around it to somebody further down the line.

The ones waiting stand in a row well behind the desk, at doll size, so the robot at the desk is always the one doing the work.

Mimi the copier

The tall machine at the right end of the arc is Mimi the copier. Set anything on her upper platform and she scans it — Mimi herself, the mime beside the machine, reaches up and follows the scan down with her hands, gathers the copy out of the air and lowers it to the tray; an independent, exact copy drops into the lower tray — contents, names and all. Click a surface with an empty hand to take from it (the tray first, then the original). Robots use Mimi exactly the way you do, which is how a robot copies things mid-program. She copies anything — a copied bird serves the same nest, a copied nest joins the flock so deliveries broadcast, and a copied robot arrives with its training, its name and its whole team. A robot that copies itself this way and sets the copy to work in a new room is a recursive program.

Dusty and Ruby

Two helpers live in front of the table. Dusty the vacuum removes: click him to wake him, then click things to vacuum them away, entries off notebook pages, or parts of a robot's thought (leaving an empty hole, which then matches anything). Click a thing's name plate with him awake and he goes over and takes just the name off; the thing stays. Typing while holding a model, a bird, a nest, a house, a sound, a scale or a notebook names it. Ruby the eraser generalises: wake her and click a part of a thought — a 7 becomes any number, then anything. Click a box’s own frame and the whole box becomes any box, whatever its holes said; click a hole to loosen that hole alone. She also erases real things in place: an erased number stands for any number, which is how you build a robot's expectations by hand. Waking one settles the other, and whoever is awake fidgets.

Dusty on a notebook page takes that entry; with Shift held he takes that entry and every other page that reads the same — the way to clear a notebook a robot has filed the same thing into a thousand times.

Dusty takes a whole stack too: point him at one and it leaves the world — that is how a puzzle comes to have fewer stacks, and the rule is saved with the world. A cube of the stack rides on his head; click it and the stack is back.

Dusty’s bag

What Dusty swallows is not gone at once: it rides on his head, where you can see it. Click it and it comes back into your hand. That is how you take one piece out of a scene to look at it on its own — point him at the piece, then take it off him and set it on the table.

He keeps the last six things. Older ones fall out of the bag for good, which is what a vacuum is for. Undo also puts a thing straight back where it came from, and empties the bag. It works the same wherever he took it from — off the table, out of a box, or off a page of a notebook.

Rooms

Rooms are little houses that each hold an entire workshop. Drop a robot on a room and it steps inside, ready behind the desk. Drop anything else on the room and it lands on that desk — and the robot inside gets to work the moment your world goes quiet. The chimney smokes while somebody in there is actually working; a room merely holding unopened deliveries sits quiet.

Click the roof to switch between solid walls (the room works instantly, unseen) and glass (you watch it work, round by round, at your speed setting). The big lever on the front, beside the door, runs and stops the room: up, the robot inside works; down, it rests. Click the door to step inside: the room becomes the world around you, and the world you left shrinks onto the table as a little room of its own — walk back out through its door. If the room was running when you opened the door, its robot picks straight back up once it has grown to full size. Birds fly in and out of rooms to reach their nests, so a machine in a box can feed a nest on your table.

The robot turns to face you when you step in. Through glass walls a robot walks to whatever its round touched, so it may be looking anywhere when you open the door — it squares up to its desk between rounds, and if you catch it mid-round it turns round to greet you before carrying on.

Robots can build rooms too. A robot may take a room from the stack, drop a robot in and something for it to work on, and stow the whole house in a hole of the box it is holding — a machine that builds machines. Rooms inside rooms work as well, all the way down.

Giving a behaviour to something else

A behaviour works on one thing. Drop it on another and it moves there: its panel is that thing's inside now, so the bird on its perch goes to the new thing, and any channel nest inside (edge, touch, speed) is re-pointed — the card says how many. Wake Ruby and click it to let it go again, and it works on itself.

A copy of a live thing is its own thing with its own name — two things answering to one name would make the mail ambiguous — so a behaviour bound to the first goes on working on the first. To drive the copy, copy the behaviour too and drop it on the copy. What copying does NOT rename is an ordinary nest's name: sharing that is joining the flock, and a bird's delivery goes to its own nest and a copy to every other nest of that name. That is how one sender drives a whole squadron: copy the behaviour that LISTENS, bind each copy to its own thing, and one posting reaches them all. The one exception is a private channel: a nest on a panel with a bird to it on the same panel (a stopwatch's readings) is the copy's own, renamed with its bird — or the birds of both panels would deliver to whichever nest was found first.

“.” stops the robots, not what they have already sent. Orders posted to a nest are still in the pile and whatever reads them will carry them out, so a thing may go on moving for a while after its behaviour rests. Press “.” on the thing itself to stop that too.

What a tooltip says

Point at anything and the card under the pointer has two halves with a line between them: what THIS one is — the words on the pad, the note somebody wrote on a behaviour, how many things ride on it — and then how anything of its kind is worked. The second half is the same every time, so once you know it your eye can stop at the line.

A behaviour can carry a note of its own, the way a robot does: hold it and the field at the top of Trained actions says a note about this behaviour. Write what it is for in your own words; it goes with the behaviour into a saved world, a saved thing and every copy, and it is the first thing its tooltip says. A world that ships behaviours you are not meant to open — a resort's cottages, a game's pieces — can say so there.

Bringing files in

Import file in the ⋮ menu, and dropping a file anywhere on the page, are the same door. What arrives depends on what the file is:

• a picture — a pad with the picture on its face, where you dropped it; drop it on a pad that is already there and it covers that one instead;
• a sound (.wav, .mp3, .ogg, .m4a, .flac, .aac) — a speaker holding the recording;
• a text file (.txt, .md, .csv) — a pad with the writing on it, sized to suit how much there is. A poem, a word list or a grammar can be written elsewhere and brought in;
• a 3D model (.glb) — a thing you can hold, named after its file and sized so its longest side is a hand's width, standing on its feet. From there it is a thing like any other: copy it, file it on a page, give it a behaviour so it wanders, carry it out to the yard, show it to a robot. glTF is the format because every character in this workshop is one, so the workshop already knows how to read it: export a .glb, which holds everything in one file. A .gltf works only if it is self-contained — one that points at a .bin and a folder of textures has nothing to point at here. A model may also be squeezed (Draco, meshopt) or carry its pictures as Basis textures, and the workshop has no unpacker for those. None of that is a mystery when it happens: the workshop says which of them it is, and the same model is nearly always offered plain as well — a .glb that is not squeezed. Nine megabytes is the most one may weigh, because a model rides inside the saved world the way a picture on a pad does;
• a saved thing — it arrives in your hand;
• a saved world — it replaces the workshop.

Where a thing is

A thing riding on a pad is part of a scene. It travels with the pad, and clicking it does not lift it — wake Dusty and click to take one off, click what he is holding to take it back into your hand, and drop it on the pad to put it back.

A thing standing on the table has a place, and its place is data like everything else. So does a thing riding on a pad — then the pad is its field, and its place is measured from the middle of that field in the same steps. Everything below means the same in both, which is why a behaviour trained on the table works unchanged on a field, and why the edge means the edge of whatever you are standing on.

Send its bird:

And a thing can have a speed, which is when it starts moving on its own — on the world's clock, smoothly, whether or not any robot is doing anything:

A thing with a speed is the difference between a game and a demonstration: its robots stop being responsible for moving it and are left with the only interesting question, which is what to do when it hits something.

And three things to doze on:

And three the original's pictures had, for things that come and go:

Behaviours

A behaviour is a pad whose panel carries robots, and those robots speak about my thing through the bird on the perch — the pedestal beside their desk, which on a panel holds a bird to whatever thing the panel is the inside of. The box they work on holds no bird to the thing at all. Load behaviours/📚 library from the examples for a shelf of them.

To use one: drop it on your thing, then press Space on it. . stops it, and waking Ruby and clicking it lets go again. Binding is not editing — nothing on the behaviour's panel changes, only which thing its panel is the inside of.

SPACE and “.” act on whatever the pointer is over, so the keyboard always belongs to the workshop: a button you have just clicked hands it back at once, and only a field you are genuinely typing in keeps it.

And a pad with things riding on it is a scene: SPACE on the pad switches on everything standing on it, and . stops the lot. The pitch is the game; the ball and the bat are its parts.

Point at any pad and press Enter and the camera goes and looks straight down at it, framed so the whole face fills the window however wide it is. That is playing: the workshop's cards, its tooltips, its wiggle and the pointer itself all get out of the way, because they belong to the bench and not to the game. The bar stays, because Pause lives there.

Escape comes back to the view you left. That is how you play a game that lives on a pad — and it is not a screen or an overlay but this workshop’s own camera, moved, so everything still works from there: the pointer still drives what follows it, SPACE and . still switch things on and off, Dusty still takes a piece off the board.

Enter works on anything, not only pads. A pad is read from straight above because a pad is a page; a number, a box, a bird, a house is flown up to and looked at from the front, at the angle you were already watching it from. There the ← and → arrows turn it a quarter at a time and ↑ ↓ tip a number over, so you can read all six of its faces — the words, the mixed fraction, the scientific notation — without picking it up. The writing always lands the right way up, and so does the writing on the faces you are not reading: each one is rolled to whichever quarter turn reads best, up the screen for a face seen side-on and away from you for one you look down on. A cube left tipped on the table has no upside-down faces and none running up its side. Escape comes back, and leaves the thing turned the way you left it.

Holding a pad is a different thing: that is for reading it and typing on it, which is why space writes a space when a pad is in your hand. Holding one, Ctrl with the left and right arrows sets its width and up and down its height, so a board can be made taller without writing a message box.

And whether a thing is in the way is data like everything else:

Solid is the default and has to be: it is what makes a ball bounce off a bat. A score, a title, a line down the middle of a pitch is told otherwise once, and is then simply part of the scenery.

A behaviour that has been switched on runs until you switch it off — and if it carries a speed, that waits for the switch too: SPACE starts the whole thing, robots and motion together, and . stops the whole thing.

Dropped in the middle of another pad it does not bind — it climbs aboard as part of the scene, the way a ball is added to a pitch. To give a pad its behaviour, drop it on the pad’s edge; anything that is not a pad binds wherever you drop it.

Set one down on its own and switch it on and it does its thing to itself. That is not a demonstration mode: a pad's panel is its own inside until somebody has said otherwise, so the shelf is legible by watching.

Nothing in a behaviour is built in. Open its panel and you will find ordinary robots sending the messages above. Bouncing is three robots that differ only in the word they expect from the edge reading, and flipping the step is a ×−1 dropped on a number.

Devices

The workshop has senses of its own, and they are nests. Press Devices in the ⋮ menu and a notebook arrives in your hand; take a nest off one of its pages and it is already wired up.

Nothing new had to be invented for this. A robot facing a bare nest dozes — that has been true since the first list — so a robot given a keyboard nest wakes once per key press and waits in between. Waiting for input is not a feature; it is what dozing already was.

They are read-only, by construction rather than by permission. Each arrives with no egg, so no bird can ever be had from it — and a bird is the only way anything is ever put on a nest. Nothing you build can write to the keyboard.

Sharing a name is joining a flock, so a second nest taken out of the notebook receives the same mail: two robots can watch one keyboard, and a world saved with a device nest in it comes back wired up.

Dusty's bag is an undo for a gesture you made: whatever you last vacuumed rides on his head, and clicking it puts it back in your hand. A robot replaying what it learned does not fill it — it made no gesture, so there is nothing to give back — but a robot you are training does, because that is you doing it.

The pen. [set | pen | down] makes a thing draw as it moves: every move leaves a chalk stroke from where it was to where it is, on the table or on the field it rides. [set | pen | up] lifts it, [set | pen | clear] rubs its lines out, [query | pen | bird] answers “down” or “up”. A finished trail, from pen down to pen up, is a thing of its own (see A trail is a thing, below): Dusty can take it, a robot can be shown it, and it is saved with the world. The turtle answers the words pendown and penup posted to its letterbox.

A turtle, and it is not built in. `examples/behaviours/🐢 turtle` takes Logo’s two orders — [forward | 3/10] and [right | 90] — and neither exists in the workshop. The turtle keeps a NEST as its letterbox; give an order to the bird and she posts it; the robot whose thought names that word wakes, does it, and eats the order. Forward is across + n × sin(heading) and away + n × cos(heading), which is why it had to wait for approximate numbers: before them a turtle could only have turned in quarters. An idle turtle is asleep and costs almost nothing. And an order posted to a turtle nobody has switched on WAKES it: her nest was only asleep inside the closed panel, and the post hydrates the panel and starts the team.

Some numbers are approximate. Hold a number and type sin, cos or root and it takes that badge. Drop a sin badge on a number of DEGREES and it becomes its sine; drop a root badge showing 2 on a number and it becomes that number’s square root. Those answers are approximations, so they wear a wavy equals and read as decimals: ≈ 0.707106781187. An approximation is dressed differently all over: a broken frame on every face, so it reads as not-exact at arm’s length; a words face that reads it aloud (“about one point four one four two…” — never the trillion-part fraction spelled out); and an underside that owns up: not exact — only the first twelve decimal places are kept. Touch an approximation with anything and the answer is approximate too — that is the only way an exact number ever becomes inexact. A root that comes out whole stays exact: the square root of 4 is plainly 2.

The sums are worked out from series over fractions, never from the machine’s own sine, so every machine gets the same twelve decimal places and a saved world replays digit for digit.

Size is sayable. [set | size | 3/2], [move | size | 1/4], [query | size | bird] — the same number the held card’s + and − buttons step, and every kind of thing has one. And [set | speed | …] now announces the new speed on the thing’s #speed channel, so a behaviour can react to how fast its thing is going.

The shelf is fifteen. The second six anima-gadgets: grow when bumped, shrink when bumped, make a sound on hit, reverse on collision, speed limit, and send 1 to the score when hit — and three more since: following up and down, bouncing at a speed and reverse a speed on collision. BUMPED means one thing running into another: being touched is what a click does, and a click picks a thing up, so nothing you do with the pointer sets these off. (A message may still say touch, which every saved world spells that way; bump and hit mean the same.) The bump gadgets DOZE until something actually runs into their thing, and act once per change of contact. The speed limit weighs the speed against the limit on an ordinary scale — the scale is the if — and is born too fast on purpose, so SPACE alone shows it braking itself. Reverse handles things and leaves edges to bouncing: bind both to one star and you have a pong ball with no training anywhere.

A copy is wholly its own. Whether it comes from Mimi, off a notebook page, or out of a robot’s thought, everything inside the copy gets fresh names — its own senses, its birds to itself, riders’ wiring to each other — so a copied game and the original play side by side without crossing. What a copy refers to outside itself stays shared on purpose: a copied bird serves the same nest, a copied nest joins the original’s flock, and both bats hear the same pointer.

Pause stops the robots, and only the robots. While it is paused no robot takes a fresh turn, at the bench, in a house or on a panel — but everything else goes on: your hands work, Mimi copies, birds finish their deliveries, eggs hatch, and a thing moving under a speed a robot gave it keeps moving (a ball does not stop because its robots did). Press Run and the robots carry on from where they stood.

A game resizes whole — and still plays. Hold a scene — a pitch with its ball and bat riding on it — and the + and − buttons on the card resize everything together. A rider’s place is said in the field’s own units whatever size it is drawn, so the same program plays the same game at every size.

The game starts at the ball. SPACE on a thing that has behaviours BOUND to it switches them all on as one, and “.” stops them — the player’s eye is on the ball, not on the cards that drive it. And a behaviour switched on while its bound thing is not here says so, and says what to do: wake Ruby to make it work on itself, or drop it on a new thing.

Stopping stops the moving too. A thing that is travelling under a speed rests where it is when you press “.” on it, and goes on again at the same speed when you press SPACE — whether the speed came from a behaviour bound to it or from a message you sent by hand.

A paused workshop looks paused. A robot holding still is easy to miss, so the light goes cold and low instead, and the ground goes blue. Press Run and the warmth comes back.

A named thing is not spare words. Pads join at the edges — “Talk” on the right of “Toon” makes “ToonTalk” — but a pad that has a NAME, or that behaviours are bound to, will not be swallowed that way: it says so and stays whole. Drop it in the middle of a pad instead and it rides there.

Nothing builds a face that nobody can see. A pad's face is a canvas, and finding the largest type that still fits means measuring the words again at every size it tries — about a millisecond. A behaviour's robots build a message and hand it to a bird every round, inside a folded panel where no face can be seen by anybody, so pads built out of sight record their words and paint nothing. The face appears the moment something could look at it, and the copies that are consumed within the round are never painted at all — and since a face that is never painted needs no canvas either, one is not made until the first time something is drawn on it. A robot's round went from 8.2 milliseconds to 2.8.

A world imported mid-project arrives whole. Its notebook’s FIRST page is the entire world in one long box, with every hole named; the pages after it are the pieces on their own. Take the box and everything that comes out of it still knows everything else that came out with it — because a page hands out a copy, every copy is renamed so it cannot steal the original’s mail, and renaming a whole box at once keeps the names inside it agreeing. Lifting a thing out of a box afterwards is a move, not a copy, so nothing is renamed again. Take page one twice and you get two worlds that share no names at all, each wired to itself.

Robots in glass houses walk their rounds. A transparent house used to show its robot swaying while the work happened invisibly; now the miniature walks to each hole its round actually touched, bows at it, and returns to the desk. A robot WOKEN BY MAIL performs its round too, and its walk outlasts the round: a house driven by post is busy for the single instant the round takes and quiet again immediately, which left the very robots an activity is built around standing still. And a house lays out the STACKS AND TOOLS its robot needs, so a round that fetches a fresh number is seen going to a number stack for it. Only what that robot's program calls for is shown: a house whose robot makes nothing has nothing standing in it, and a house with its walls solid has none of it at all.

The turtle is a dispenser as well as a pen. [drop | sphere | 1/10] — or cube, tube, cone — sets a solid of that size down at the thing’s position and orientation, in the pen’s colour. Dropped shapes join the pen’s current trail, so a sculpture of shapes and lines sweeps up as ONE thing and saves like any trail. A tube lies along the way the thing is pointing.

A trail is a thing. Wake Dusty and point him at any stroke: the whole trail, from pen down to pen up, goes into his bag as ONE object — take it back out and set it down anywhere, save it with the world, sweep it up again. A turtle’s drawing is a sculpture once it is finished.

Models can be imported. A model is a thing built of PARTS — boxes, spheres, cylinders, cones, each with a place, a turn and a colour — small enough to write by hand and read back. Import file on a .thing.json carrying one puts it in your hand; examples/models/ has a toy airplane and a dragonfly, both facing heading zero. Drop the 3D turtle behaviour on one and it flies. An import always arrives with fresh names, so importing the same file twice gives two things that share nothing.

A bird flies house to house. Mail from one house to another crosses your table in full view, the same way mail from a house to a nest on the desk does — which is the flight that says what an activity is doing, since in activity1 the only nests Add 1 feeds are the ones inside Doubler and Split. Every nest that answers to the name is fed, one bird apiece — and a letter posted while she is still in the air JOINS HER, so one bird flies at her own pace however fast the sender runs, and sets her whole post down in the order it was sent. A folded behaviour’s letterbox is not a house: its post arrives at once, or a turtle’s orders would each take a second to land.

A document arrives as a page. Import a .md file and the pad renders the markdown rather than quoting it: headings in their sizes, bullets hanging, numbered lists, quotes ruled down the side, fenced code in a mono face on a tint, and bold, italic and code read inside a line. Anything markdown can do that a pad cannot show — a table, a link — stays as its own plain text rather than disappearing. It is a mark on the PAD, not on the file, so it survives a save, a copy, and a robot handing the pad to a bird. A page is drawn at more pixels than a pad usually gets, because twenty lines of small type need them where one word does not.

A long document has pages. A page is laid out at a size meant to be READ, and what does not fit starts the next page — the behaviours README comes in at twenty-three of them, numbered in the corner. ] and [ (or PageDown and PageUp) turn the page you are pointing at or holding; the arrows are left alone, since they already turn a pad. The page you left it on is part of the pad and travels with it.

A nest shows ten and says how many more. At Instant speed a sender can outrun the robot reading its mail for as long as it likes — zeno’s halver posts as fast as it runs and the totaller takes one a round — so a nest may hold hundreds. It stands ten of them up, with … 152 newer … over the rest, and mail that arrives into a backlog is tucked straight onto the pile rather than performed one letter at a time.

Behind glass, the post is paced by its own delivery. A house that has handed a letter to a courier waits for it to be on the nest before taking another round — so what you watch is every delivery, one bird at a time, and stopping a house stops its arrivals within about one flight. No backlog can build up behind your back; only Instant speed lets a sender run ahead.

The lever means stop. A house woken by post is only briefly “busy” — between letters its robot dozes over the nest — but the switch remembers being thrown: a house you set going stays “on” through its dozes, so pressing the lever stops it whatever instant you catch it in, and pressing it again sets it going.

Panels have doors. Every panel carries the same door a house has; walk through it and the panel’s world takes the stage at full size, its robots running where you can watch them, the tall door leading back out.

A panel dropped on a panel nests whole. The card and its tray both move onto the group’s own bench, shrinking with its world, visibly part of it. The nested gadget drives the group’s subject, and lifting it back out restores its independence.

Folding a panel never freezes what lives inside it. The knob folds a panel back into its thing — but a running panel nested inside is live work, and a fold over live work keeps the tray on the bench, closed, where its robots carry on out of sight. Mail addressed to a letterbox inside a folded panel still arrives, and the bird comes down on the thing the behaviour drives — the airplane, not the empty spot where its panel used to stand.

The robot’s hand is at the stack. Taking from a pile, the robot picks the arm pose that meets the pile-top’s height and walks to where that pose’s claw lands on the pile — so it reaches the top number itself, not a spot beside it, and a drop onto a pile is released at the target rather than floating over from desk height. A pile taller than the arm is reached at full stretch, directly underneath, and the top floats the last of the way into the claw.

The robot reads its own notebook. Each round, the first step that looks in the notebook takes a snapshot of its pages, and the whole round reads from that. So the notebook is never locked by a robot: hold it, flip it, edit it mid-run — the round is untouched, and the next round sees what you changed. What a robot FILES still goes into the real notebook, because filing is how a robot publishes.

Undo never mints a twin. Undoing a drop brings back the very thing that moved — out of whatever tray or hole it landed in — never a fresh copy of it. A live name is one thing, through every undo.

The robot reaches for the top of the pile. Taking a delivery off a nest, the arm rises to where the top actually stands and grabs it there. A pile taller than the arm is grabbed at full stretch, the thing crossing the last of the gap on its way into the claw.

Stepping inside is the training view. Walk through a house’s door and the camera settles at the workshop’s own vantage — over the robot’s shoulder, its desk and work spots in front of it — the same tableau as training a robot or watching one you have just trained. Walking back out settles it the same way.

A running robot does not freeze the switches. A house and a behaviour can be switched on and off with SPACE and “.”, or by the house’s lever, whatever else is working — including while you are standing inside another house whose robot is mid-round. What a robot is working on is still off limits while it works; a switch never was.

A pause cuts the power. While the world is paused the robots hold still — no swaying behind glass, no walking a round, no smoke from the chimney. Birds still finish their deliveries and the levers still swing, because a pause is the robots stopping, not the air freezing.

The edge speaks. A thing standing against the table’s edge and told to walk into it says so — “that move could not go anywhere” — instead of silently ignoring the order.

A thing can fly. [set | up | 1/2] floats it above the table; [move | yaw | 90], [move | pitch | 30] and [move | roll | 45] turn it about its OWN upright, nose and line of travel; [move | forward | 30] sends it that far along the way it is pointing, in three dimensions; and [set | home | yes] puts it back level, facing the far edge, on the table. Turns are always move, never set, because a turn is relative by nature — that is the whole point of a turtle.

A loop needs no counting. examples/models/✈️ airplane-flight is a toy airplane that takes off, flies and loops, and its pilot has no counter, no phases and no comparisons: its whole round is three orders, always the same three — [move | 10], [move | 10], [pitch | 30]. Turn the same few degrees after every stride and the path closes into a circle; twelve rounds is a full turn. TWO behaviours are bound to the one airplane and one SPACE starts both: the 3D turtle, which gives it move, yaw, pitch and roll, and the pilot, which speaks them. Its pen is down, so it draws the loop it is flying and you can pick the flight path up afterwards. Post [roll | 30] to its bird while it flies and the loop tilts — roll turns about the line of travel, so it changes the plane the loop is drawn in.

The frame is kept as ONE orientation, multiplied and renormalised at each turn, not as three angles side by side. So the turns compose in any order without drifting and without a gimbal to lock: ninety one-degree yaws land on exactly the same frame as a single ninety-degree yaw, which is what lets a staircase built out of many small turns actually close.

The pen has a colour and a width. [set | pen | red] draws in red from there on; [set | pen | 3] makes the line three ordinary widths wide. Each stroke keeps the colour and width it was drawn with, so one drawing can change its mind halfway. [set | pen | invisible] (or transparent) is ink nobody can see: the pen goes on drawing, so a drawing whose parts stand apart — a flower’s petals, the eyes of a face — stays ONE trail from pen down to pen up, one thing for Dusty to sweep up and one thing to save; any colour brings the ink back. And chalk comes off: wake Dusty and point him at a stroke and that stroke goes, leaving the rest of the line.

Which way a thing points. [set | facing | 90] turns a thing, [move | facing | 30] turns it further, and [query | facing | bird] asks. Zero points at the FAR edge — of the table, or of the pad a thing is riding on, since a rider’s angle is measured in its field’s own frame. Degrees run clockwise, so a right turn adds. That is the same frame a step forward has always used (across is the sine of the heading, away is its cosine), which is why the turtle now points the way it is about to walk: its right hands the thing a [set | facing | …] with the new heading in it.

A pad can have no paper. [set | background | none] and the writing stays while the card goes: a turtle is then a turtle, not a turtle on a tile.

The turtle speaks Logo’s units. forward 100 is a good stride; forward 30 crosses a tenth of the table. The scale is not hidden in the robots — it is a number in the turtle’s box called step size, one hundredth, and every step is multiplied by it. Change that one number and the whole turtle changes gait. Its box says what each of its ten holes is for, so opening the panel tells you the machine rather than making you work it out.

A sound is made by a box, however it arrives. Drop a [frequency | seconds | shape] box on a sound and it sings; give that same box to a bird addressed to the sound and it sings just the same. What your hand can do to a thing, a message can do.

A behaviour may hold behaviours. Put anima-gadgets inside another one’s panel and you have a MACRO: its parts grouped by purpose — movement in one, sounds in another. SPACE on the macro sets every part going and “.” rests them all, and a part does not drive itself: it drives the thing the macro drives. Take a part out again and it works on itself as before. That is what makes a macro one behaviour to the person holding it and several to the person opening it.

Off is a decision. A behaviour you stop with “.” stays stopped. Post wakes a team that is merely idle; it does not overrule you. (Before this a behaviour listening to the pointer could not be stopped at all: the next pointer reading, sixty times a second, started it again.)

Scenery. Solid is the default, because that is what makes a ball bounce off a bat. Anything that is there to be READ — a title, a score, a card of instructions — should be told [set | solid | no] once, or the ball collides with your documentation and, if something is counting hits, scores against it.

Moving on the clock, not on a turn. Two shelf behaviours move a thing by sending it a step every round; two others set a speed and then sleep until something happens. The second kind moves perfectly evenly and costs nothing between events, because the world’s own clock does the carrying — a robot cycle builds boxes and flies birds, and three of those on one ball cost about 26 milliseconds a frame against 0.2 for the speed-based pair. Both kinds are on the shelf; bind one, then the other, and watch the difference.

Binding lands anywhere on the panel. Drop a behaviour — or its own open panel — on any part of another thing’s panel (the floor, the work box, the perch, a plaque) and it binds to that thing. And the target may itself be a behaviour: drop the speed limit on a game’s ball and you are limiting the ball. As with any pad, the middle means ride — the edge means bind.

Dusty switches off what he takes. Vacuum a running behaviour and it goes into his bag switched off; take it back out, put it down, and press SPACE when you want it going again.

A behaviour dropped on a thing’s panel binds to it. Drop a working ball on a picture’s panel (or drop the ball’s own open panel there) and the picture obtains the behaviour: the ball’s robots now work on the picture. The behaviour itself stays on the table — press SPACE on it to set it going.

Importing a world mid-project lands as a notebook. With work on your table, a world file arrives as a notebook of its things — one per page, named after the file — and wipes nothing. Take copies off its pages. Import into a fresh workshop to open the file as the whole world.

A thing off the table is out of play. Pick up something that is switched on — or put it in a house, in a hole, on Mimi’s platform — and its behaviour waits. It is still switched on, it just has no place of its own to move in or read from until you put it back, and then it carries straight on.

Marty the Martian

The little green fellow beside Dusty and Ruby is Marty. Click him and ask anything about the workshop — or say "show me birds" (or fractions, numbers, pads, boxes, dice, scales, robot, copier, dusty, rooms, notebook) and he demonstrates it right on your table, using the workshop exactly the way you do — holding the pieces in his own hand. A demonstration plays one narrated step at a time: Marty walks to the stack, fetches what he needs, carries it to the table, does one thing, and waits for you to click Next ▸ — Stop ends it, and so does asking him something else. When an answer of his suggests a demonstration, you get a Show me button rather than a surprise performance. In the ordinary setting he never builds programs for you — doing it yourself is the whole point; How Marty thinks has two settings that let him plan one with you, or build one together, described below.

Marty thinks with whatever brain he has. Without one his replies are canned lines from a phrasebook — he can pick the right demonstration, but he is not really answering. For real conversation open How Marty thinks in his panel and choose a brain.

Gemini Nano is the easiest: desktop Chrome carries a small model inside it, so there is no key and no account — pick it and he can talk. The model is a download of gigabytes, so the panel asks for it with a button of its own rather than starting it behind your back; it happens once, wants a fair amount of free disk, and the panel says when it is ready. Nothing you type leaves the machine, which is what makes it the one brain a classroom can have without handing out a key. Being small, it cannot hold the whole manual at once, so he is handed the sections your question is about rather than all of them — he is likelier to say he is unsure than the larger brains are.

A model in this browser is the experimental choice: an open model (Qwen, Llama or Phi) runs on your computer’s own graphics card, so again there is no key and nothing leaves the machine. It needs a browser with WebGPU and a graphics card with several gigabytes of memory; the panel lists the models with their sizes, and a button downloads the one you pick (a few gigabytes, once) and loads it, which takes a minute or so each time the page opens. It is not offered in a Claude artifact. It is marked experimental because it is much less reliable than the brains over the network: tried on the hand’s test sentences it got about six in ten right, where they get nearly all.

The others — Claude, ChatGPT and the full Gemini — talk to their companies over the network, so each wants that provider's API key pasted in; the key is kept only in this browser, and a network is needed to reach them. Whichever he has, he also sees what is on your table when he answers, and the panel always says which one he is using right now.

While he is working out an answer, three dots circle over his antenna and his antenna light runs hot and quick, and his panel says thinking — so a wait is never a wait on nothing. The brain built into Chrome is the slowest to answer the first time, because Chrome has to wake it.

Whatever brain he has, Marty answers from this manual — the page you are reading is handed to him with every question, so what he tells you is what is written here rather than what a model imagines a workshop like this might do. If the manual does not say, he is asked to admit he is unsure.

Marty can also speak and listen. The 🔊 button has him read his replies aloud, a little high and quick with a drift between sentences. How Marty thinks also sets how far he goes: hints and demonstrations only keeps the building yours (the default); may plan and build programs when asked lets him lay out a program step by step in the workshop's own gestures, saying the idea first so you can stop him and build it yourself; plans and builds a program together with you makes him a partner — he asks what the program should do, one question at a time, says the plan and checks it, hands you one move at a time and watches the table for it, and when you are stuck does what he can himself — his hands-on move is to fetch one fresh thing from a stack and set it on the table (a little robot, a number, a box, a nest), or to offer a demonstration; he cannot train, erase or run anything for you, and he says so rather than claiming to — and hands the move after it back. He never builds the whole thing for you in any setting. Words chooses the workshop's words, or computing words too: with the second, the programmer's word stands beside each workshop word the first time it comes up — a thought (its condition), a bird (a message), a house (a process). Commentary while a robot works has him say, at the start of a run, when it stops and when a behaviour is switched on, what the robot is trying to achieve and the trick it uses — as a good comment would, not a transcript — and, during a run, one line before every step saying what that step is for. The robot waits for each line it is given to be heard, so the narration sets the pace; but it never stands still waiting for him. His opening line is read while it works, and a line he cannot say at that moment — his opening still going, or a pad being read aloud — is not said at all rather than queued behind. His lines for the steps are made once and said again on every round, so they name a hole by what it is rather than by the number it happens to hold this time round. Commentary keeps to Speed 1× and ½×: faster, the robot is ahead of any sentence, and a run sped up mid-way stops being narrated there and then. Ask him about a robot, a behaviour or a house — the one in your hand, or one on the table by its name or its words — and a button under his answer runs it with commentary. Everything read aloud — his answers, a card's message, a pad's own voice — has the pictures taken out first: an emoji stands beside the word it illustrates, so reading it would say the word twice ("press the microphone microphone"). Arrows and arithmetic signs stay, since "the ← and → arrows turn it" is a sentence about arrows. How Marty thinks lets you pick which of your browser's voices he uses — the list puts the ones that speak your language first, since a voice meant for another language reads English with an accent. Left alone he takes a woman's voice where your browser has one; the high pitch and the drift between sentences are what make him sound Martian, not which voice it is. That choice, and whether the messages under the title are read aloud, belong to whoever is signed in — like the notebook, they are kept under your name, so picking a voice does not change it for everybody else who uses this browser. The 🎤 button lets you ask by voice, where the browser offers a microphone — where it does not, the button simply is not shown. A Claude artifact is never given the microphone, so there a press of it puts the cursor in his question box and says how to start your computer’s own dictation instead (below, under Speaking to your hand). The sound slider in the menu sets how loud every voice is as well as the effects, and the mute button beside it silences them all.

Asking Marty for a toy

Next to Ask in Marty’s panel is Make. Type what you want — a red sailboat, a teapot, a dragonfly — and he builds it out of solid shapes and sets it on your table. It is an ordinary thing from the moment it lands: pick it up, copy it on Mimi, drop a behaviour on it, file it in your notebook, save it with the world. If you did not want it, Undo takes it away. You need not find the button: a wish that starts with the word — “make me a lion”, typed into Ask or spoken into the microphone — is Make, and “draw a cat” is Draw.

Say what is wrong with it and he makes it over. He remembers the last toy he made, so “good, but it should have six legs” or “make the sails blue” changes that thing rather than building a second one beside it. The old one stays, on the nearest free spot: you cannot judge what you asked for against what you got once the last one has been thrown away. Sweep the ones you do not want into the dust bin. Name something else and he starts fresh.

A toy carries its own recipe. Open a made thing’s panel and press the ⓘ: its info notebook has a page saying what it is made of, a page saying how to change it, and a page holding the source — the list of shapes, sizes, places and colours it was built from. Save the thing to a file, open the file in any text editor, change a number or a colour, and import it again. The file is laid out to be read: one part to a line, with its numbers kept together.

Asking Marty for a picture

Where the brain can paint, Draw paints. With OpenAI or Gemini as Marty's brain, Draw asks for a picture and it arrives on a pad; Claude and the brain inside Chrome cannot paint, and Marty draws with the turtle instead. The key goes to its own provider and nowhere else, exactly as it does for words.

Beside Make is Draw. Type what you want — a snowflake, a spiral, a house with a tree — and it arrives on a pad on your table, an ordinary pad you can pick up, caption, copy or ride things on.

He draws by walking a turtle, in the very words you already know from the turtle: forward, back, right, left, the pen up and down, a colour, a width, and repeat for the parts that come round again. That is the point of doing it this way — the picture is not a wall you cannot get behind. A snowflake is six of something repeated, and you can see that it is.

Say what is wrong with it and he draws it again: “bigger”, “in red”, “more points”. Each one lands on a free spot of its own and the earlier ones stay where they are, so you can put them side by side and see which you liked. Ask for a picture on a transparent background and you get one, which is what a sprite for a game wants.

A very elaborate toy may come up short. There is a limit to how much a brain can say in one answer, and something with a great many parts can reach it. When that happens he hands you what did arrive and says so, rather than pretending it is finished — ask again and he will have another go.

He makes things, never programs. Marty will not design a program for you and never has — working it out yourself is the whole point of this workshop. A toy is the opposite of a program: it arrives doing nothing at all, which is an invitation. What it does is still yours to train.

Making needs a real brain, so it wants one of the choices under “How Marty thinks” — his phrasebook can pick a demonstration but cannot invent a toy, and he says so rather than pretending. Everything he sends back is checked before it is built: only boxes, balls, tubes and cones, only real colours, and always a size your hand can pick up, so a strange answer makes a strange toy and never a broken workshop.

Your hand, by words

You can tell your own hand what to do. Say or type “pick up a 1 and put it in a 3-hole box”, “make a pad that says ToonTalk” or “give a robot a scale with 1 and 100 on it”, and your hand does it — the same clicks and key presses you would have made yourself. That is the point: it is not Marty doing things for you, it is another way of moving your hand, so Undo takes a step back as always, a puzzle’s rules still apply, and inside a thought bubble the hand is the robot’s claw and what it does is what the robot learns.

It needs a brain — any of the choices under How Marty thinks. With one chosen, the ⋮ menu has Move my hand by words (and the Settings card has the same switch); tick it and a line appears at the top of the screen: Tell your hand what to do. Type a sentence and press Enter. Esc gives the keyboard back to the table.

“A 1” and “the 1”

The brain is shown what is here, numbered: the things on the table, what sits in each hole or rides on each thing, what is on the robot’s desk and Mimi’s platform, what is in your hand, and where each thing is on the screen — left or right, at the front or the back. It decides what your words mean from that, the way a person would: a 1 is a fresh one from the stack, the 1 is the one already on the table; the box on the left is the one you can see on the left. After Mimi has copied something, it knows which is the copy and which the original.

What it can do

Anything you can do with your hand, more or less: take things from the stacks and type on them; put them on the table, into a hole, on another thing (a number dropped on a number adds, as always); give something to a robot, or to a bird, who flies it to her nest; have Mimi copy something and Dusty vacuum it; name a thing (“call it orders”) and use the name later; file a thing in your notebook and take it out again by name; go out to the yard, into the panel on the back of a thing, and back. Inside a thought bubble it trains: “add a 1 to the number on the desk”, then “leave”. It can have Ruby loosen a part of a robot’s thought (“erase the 3 so it works for any number”) inside the bubble, or at the bench after a run stops because the robot’s desk no longer fits its thought. It can run the robot, and while one is running it can stop it, pause and resume, and change the speed (“double the speed”, “8 times as fast”, “instant”) — but nothing else touches the table until you say stop. It moves the camera too: turn left, look from higher, come closer, look at the robot, reset the view. And a question about what is here — “what is on the table?”, “what am I holding?” — is answered without anything moving. Questions about how ToonTalk works are for Marty.

When it cannot

Every step is checked before the next is tried. If one cannot be done, the line says which step and why, and the steps before it are undone, so nothing is left half-done — not on the table, and not in a lesson a robot is being taught. If part of what you asked is impossible, nothing is done at all. A tick (✓) means it was done; the answer says what a drop made (“the number it landed on now reads 4”), so you never have to take its word for it. A cross (✗) means nothing changed. A sentence you say while the hand is still busy waits its turn; stop never waits.

The small ▾ at the end of the line opens a log of what you said and what came back; What was said on the title card shows the same log with the workshop’s own messages in it too. Neither opens by itself.

Speaking to your hand

The 🎤 on the line listens until you press it again. A pause sends what you said; or, on the Settings card, give it a go phrase (“do it”) and what you say piles up until you end with it. It stops listening while the workshop is speaking, so it never hears its own voice. When you speak, the answer is read aloud as well as shown; Read your hand’s answers aloud on the Settings card does that for typed sentences too.

In a Claude artifact the page is never given the microphone, so the 🎤 there puts the cursor in the line and tells you how to start your computer’s own dictation, which types into whatever has the cursor: Windows+H on Windows (with Voice Access you can say “press Enter” to send), the Fn (Globe) key twice on a Mac, Search+D on a Chromebook, the microphone on a phone’s keyboard. The line keeps the cursor from one sentence to the next, and the words “press Enter”, if dictation types them, are left out.

Said to Marty instead, with the switch on, a sentence asking to move things goes to your hand just the same; with it off, he tells you where the switch is.

Someone who works by voice alone can get a long way: the brain is told where each thing is on the screen, the camera moves by words, and every answer can be heard. Buttons that are not on the table — the menus, Run and Speed on the bar, a puzzle’s buttons — are for your computer’s own voice control.

Which brain

The brains over the network — Claude, ChatGPT, Gemini, and Claude with no key in a Claude artifact — get nearly every sentence right, in a few seconds. The small ones that run on your own computer — Gemini Nano inside Chrome, and a model in this browser — get many wrong, and are there to experiment with. Whichever you use, nothing half-done is left behind.

The yard

Behind every place — the workshop, and every house — is open ground. The green back door stands beside the tall door out. Through it your table stays indoors and the ground takes its place: grass underfoot, ten paces by five, at floor level, beginning past Marty, Dusty and Mimi, who stand behind it as they stand beside the table. Things stand wherever you put them. Your hand, the stacks, the robot's desk and Mimi come along, exactly as they do into a house, so whatever a robot sweeps off its work spots at the end of a run, and whatever Marty makes, lands on the grass. A robot copying a house makes a village; Marty asked for animal after animal makes a zoo.

Whatever you are carrying comes through the door with you, either way. What you set down outside waits while you are indoors, is saved with the world, and a house's yard folds into the house. The sign on the door says Outside; from the yard it says Inside, or Back to the workshop. A yard entered from inside a house is that house's own, and the house is left from indoors.

Doors have names. The tall door out wears a sign saying where it leads — Back to the workshop, Back to “Add 1”. Point at any door and type to change what it says: a house's door carries the house's name; the tall door's words are kept with the house. Backspace rubs a letter out.

Doors can be moved. Click a door by its frame and it comes with the pointer along the floor; click where it should stand. The arrow keys turn it, + and − make it bigger or smaller, Escape puts it back. Where the doors stand is remembered in this browser and saved with a world.

Robots on the ground. Outside, a drop on the grass while training is a step of its own — set it down on the ground — and a run finds a free patch of grass each time. Carry out a box of animals, give it to a robot, show it taking one out and setting it on the ground: each round unpacks another. A robot taught outside and run indoors says so and stops.

The computer. The workshop’s own machine is a thing with a name, and a bird to it is on the last page of the Devices notebook (and in devices/computer, with the letters ready to copy). Give her [query | time | bird] and the clock comes back as a number of milliseconds since the workshop opened; [query | date | bird] answers with a box [year | month | day] and [query | clock | bird] with [hours | minutes | seconds]. [query | seconds | bird] gives the same clock in seconds, thousandths and all. Nothing listens: a stopwatch is built. A number can be told what it is — [set | value | n] to its bird replaces what it holds, where a badge would add to it — so four robots on a number’s own panel are a stopwatch (devices/timer): one asks the computer the time and one tells the number the reading minus a start, taking turns by a pad crossing between two holes; and when the number’s own switch says on, one forgets the start and asks the number what it shows, and one sets the start from the next reading and that value — so the count goes on from wherever it stopped, and from 0 if you set it to 0 first. SPACE on the number starts the robots on its own panel; “.” rests them; and the Stop button, pressed inside a panel or a house, stops it for good until Start. A robot or a box dropped on a thing's panel does not start it: SPACE does.

A lesson waiting on a panel. Drop a box on a thing's panel, then a fresh robot, and the robot stands behind the panel's desk with the box on it. Go in and the lesson begins as you enter: everything you do is learned, the copier, the number stack and the bird on the perch included, and a letter given to that bird during the lesson really reaches the thing (the daydream takes it back when you leave the thought). Leave the thought and press Start, or come out and press SPACE on the thing.

The perch

Beside the robot’s desk stands a pedestal, the perch. Enter a thing’s panel and a bird is standing on it: the bird to “my thing”, whatever thing this panel is the inside of. Give her a letter by hand and it goes to the thing; train a robot to put a letter on the perch and the robot’s letters go there too. That is how the timer’s second robot tells its number the time — the box it works on holds no bird to the number at all. Take her off the perch, put her in a box, and another is on the perch at once.

“My thing” is decided when the letter is given, not when the robot was trained: a card standing on another thing’s panel, or a behaviour bound to a picture, writes to the outermost thing, the way a sensor in the original belonged to the owner of the uppermost back side. So a robot trained on one panel does the same work on any panel it is moved to. On the bench the perch stands empty, and she has nothing to go to; set any bird of your own there and the robot’s letters go to her nest — the way to try such a robot out without entering a panel. Two worlds in examples/meta show a robot teaching robots to do it: telling (one pupil, one letter to the perch) and timer-teacher (the timer’s two robots, built by a teacher); a third, resort-teacher, solves Resort Infinity in front of you — seats the guests, teaches a clerk on a practice letter and gives it to the bird to the front desk, teaches a mover and gives it to the bird to the moving office, welcomes five more. A robot is a letter too: given to a bird, it flies to her nest.

Filling a yard by hand. Whatever you carry comes through the door with you: a box of things to unpack, and the empty box goes back in with you. A nest set on the grass takes the bird's deliveries, and the pile is yours to arrange where it lies. A robot copying a house makes a village; asking Marty for animal after animal makes a zoo — and “I want another lion” is a wish he makes, the same as “make me a lion”. To make an animal wander, drop the wandering behaviour on it (there is one on the zoo's grass, and one on the shelf in the behaviours library) and press SPACE on the pad: each round a die, a −2 and a ×1/25 land on its step in turn, and a copy goes to the bird. Copy the pad on Mimi for the next animal.

What is here. What is here… in the ⋮ menu is a list of boxes to tick: Marty (his panel stays), Dusty, Mimi and her machine, Ruby, the back door, and each stack. Unticked, a thing is gone until you tick it again, and the browser remembers. A puzzle's rules still decide what is there at all. Ruby comes out to the yard too, since a robot can be trained there; she works inside a thought, wherever it is. The list is the place's own: what is put away indoors is put away indoors, and the yard has its own list. So are the doors: moved in the yard, a door is moved in the yard, and indoors it stands where it stood.

A robot goes out. While training, click the back door and the robot goes out to the yard with whatever it holds — and you with it. Set things down on the grass, click the door again to come back in. The run follows the robot there and back.

The yard grows. Set something down within half a pace of an edge and that edge moves out two paces, up to a limit; the size is the yard's own and is saved with it.

A backdrop. Holding a pad, the up and down arrows tilt it fifteen degrees a press; standing, it rides high enough that its bottom edge rests on the ground, and it stays so when set down. Six presses stand a picture up as a backdrop in the yard. Models and pads grow to twelve times their size with + (Ctrl with the up arrow), doors to six.

A ground of its own. With a pad in hand, As big as the ground on the holding card sizes it to whatever you stand on — the yard, or the table — and lays it squarely over it. What you drop on it rides on it, so a pad with a picture is a beach, a floor, a map.

Reshape yard. The reshape button says which it is. Outside, the corner handles stretch the yard — the far edge and the sides; the near edge, where the helpers stand, stays — and the size is kept with the yard. A saved world also carries what you have put away, indoors and out.

The yard is a thing. A place is not a thing, so nothing could address the yard: a zoo could not count its animals, a village could not notice a house arriving. It can now. The yard’s behaviours… in the ⋮ menu, under What is here, opens the yard’s own panel on the grass (step outside first: only the place you are in runs). Its bird is the yard’s, and the yard answers two things. Give it [query | things | bird] and the bird you send comes back with a box, one hole per thing standing on the grass, each holding a bird to it, its name and its place — so a robot can not only count what is out there but tell any of it what to do. Put a word in the third hole, [query | things | lion | bird], and only the things whose name or words contain it are reported. Each entry ends with the thing’s kind — model, text, number — so a robot can tell an animal from the welcome sign. [query | each | bird] answers the same, delivered one thing at a time, which is how a robot walks a list here: it takes one entry off its nest a round. And a thing can be given a behaviour by mail: [bind | pad] to its bird sets the behaviour in the letter down beside it, binds it and switches it on, exactly as dropping the pad on it would — which is how one robot gives a whole zoo a wiggle (see yard/zoo-keeper). A behaviour handed out that way stays switched with its giver: “.” on the keeper rests every wiggle it gave, SPACE sets them going again, and “.” on one animal rests only its own and says where it came from. Give it [listen | things | bird] and the bird brings a nest that hears [arrived | name | bird to it] and [left | name] as things are set down on the grass and taken up. The yard’s name and its panel are saved with the world; SPACE on the panel sets its robots going and “.” rests them.

The words, in one place

Every word the workshop uses for a place or a thing, with where it is explained. Ken asked for this after finding perch used once without an explanation and station nowhere at all.

the table

The big surface in front of you, where things stand when they are yours. Also called the bench. Outside, the ground takes its place. Basics

the desk, its stand

The small desk in front of the robot: what the robot was given sits on it, and every step it learns speaks of that thing by its holes. A robot working aside — a pupil, or a second robot — has a desk of its own. Robots

a work spot

One of the little desks beside the robot's own: its scratch space, numbered spot 1, spot 2…, cleared onto the table when it finishes. More grow as they are needed. Robots

a station

The name in this manual for any fixed place a robot can be shown to use: its desk, a work spot, the copier's platform and tray, the perch, the notebook, the stacks. A step never names a station by position, only by what it is for ("put it on spot 2", "set it on the perch").

the perch

The pedestal to the right of the robot's desk. On a thing's panel it holds a bird to my thing — whatever thing the panel is the inside of; on the table it is empty, and any bird of your own set there takes a robot's letters. The perch

my thing

What a behaviour works on: the thing whose panel its robots stand on, followed up through nesting and binding to the outermost. The bird on the perch goes to it. The perch

a stack

The piles behind the table: numbers, boxes, pads, nests, scales, dice, sounds, houses and little robots, each giving a fresh one when clicked. Basics

the copier, Mimi

The machine to the right of the table, and the helper who works it: a thing set on its platform comes out copied in the tray. Mimi

Dusty, Ruby, Marty

The vacuum that takes things away (and gives them back), the loosener of a robot's thought, and the Martian who explains and builds. Dusty & Ruby, Marty

a thing

Anything you can pick up: a number, a pad, a box, a nest, a bird, a scale, a die, a sound, a picture, a model, a house, a robot.

a box, a hole

A box has holes, numbered from 1; a robot's steps name them ("hole 3 of what it was given"). Boxes

a pad

A card with words on it. A pad can carry a picture, ride on another pad, and have a panel. Pads

a badge

The operation a number wears (+, −, ×, ÷, set, sin…): dropped on another number, it does that to it. Numbers

a nest, a bird, a letter

A bird flies whatever she is given to her nest, where it lands on a pile, oldest on top. A letter or message is a box given to a bird. Birds & nests

a bird to a thing, a live thing

Some birds go to a thing rather than a nest — a number, a picture, the computer — and the thing answers the letter. A thing with a name of its own that birds can find is live. Places

a reading, a channel

A nest a thing keeps for what it senses (its edge, what it touches, its speed): a reading holds one thing at all times, an event nest is empty until something happens. Behaviours

a robot, a little robot

A robot at its desk is full size; on the table, in a hole or in a claw it is little. Robots

a lesson, the thought bubble, a daydream

Training: give an untrained robot a thing and everything you do is learned as steps; the world it works on is a daydream that rewinds when you leave the bubble. Robots

a thought, the condition

What a robot must be given before it runs: exact at first, loosened by Ruby. Robots

a step

One thing a robot learned to do: take, put, copy, a fresh number, a badge, a vacuuming, a teaching… The Trained actions card lists them.

a round, a run

A run is the robot doing its steps over and over; each pass is a round, and the Rounds limit caps them.

a team

Robots dropped on a robot: given a thing, the first whose thought fits takes the round. Robots

a pupil, a teacher

A robot taught by a robot, at a desk of its own; the teacher keeps the pupil's lesson as taught steps, and can pick the pupil up again afterwards. Robots

a token pad

A pad that two robots move between two holes to take turns, since no thought can say "an empty nest". Devices

a panel, the inside of a thing

Every thing has an inside: press the gear (⚙) over it and its panel comes out as a tray, a little world of its own. Drop robots and things on it, enter it by its door, fold it away by its knob. Places

a tray, a card

A panel on the table is a tray; a pad standing on another thing's panel is a card of that thing. Places

a behaviour, a gadget

A pad whose panel carries robots. Drop it on a thing and that thing is what the robots work on; SPACE starts them. Behaviours

binding

Making a behaviour's panel the inside of another thing, by dropping it there. Nothing on the panel changes. Behaviours

a house, a room

A whole workshop in a small house: a robot inside works on its own, and birds deliver through the roof. Rooms

the yard, the ground

The open ground out the back door, where things stand on the grass and the yard itself is a thing with a panel. The yard

the computer

The workshop's own machine, a thing with a fixed name: its bird answers the time and the date. Devices

a device

The keyboard and the pointer, each a nest that the workshop keeps fed. Devices

the notebook

Your own book: file a thing on a page, look one up by name, and it goes with you. Notebook & files

Start, Stop, Speed, Rounds

The buttons: run what the robot learned, stop it after the round it is in, how fast, and how many rounds. Inside a panel or a house they apply to that place.

What a programmer would call it

The workshop has one set of words for everyone. For older learners and teachers, here is the second set, the one Marty uses beside the first when his Words switch says computing words too.

Puzzles

The story is the original ToonTalk’s: Marty’s ship landed badly — it stands behind every puzzle table leaning on a bent fin, its tail scorched, big enough to have travelled in — and its computer needs numbers to work. Ask Marty what the rocket is and he will tell you.

The card at the door offers Free play — the workshop as it always was — and Puzzle game, a series of small worlds each with something to make. If you have solved some already it asks whether to carry on where you were or start again from the first; where you got to is kept under your name in this browser, beside your notebook.

A puzzle is a world file with a few more things in it, and the workshop needs nothing new to play one. Open it and Marty says what is wanted; the goal stands on the table where you can see it but cannot pick it up; the table holds only what the puzzle gives you — the stacks and tools it does not want are simply not there, and the keyboard may not reach numbers or pads. When you have an answer, give it to the bird. She flies it into the judge’s house, an opaque house whose robots decide: a wrong answer comes back to the nest marked from the judge with a note; the right one gets a note, and a Next puzzle button appears on the card for when you have read it. Start this puzzle over puts everything back as it began, and asking Marty for a hint gets the author’s hints one at a time, the last of them the whole answer.

Do step inside the judge’s house and look. The robots in there were trained the way you train yours, and reading them is how you learn to make a puzzle of your own — just not how to solve this one. The first seven puzzles — a box with 1 and 2, a 4, a box with 8, 16 and 32, a zero, a box of two zeros made by a robot you train, the total of the numbers on a nest (the first that needs Ruby), and exactly 1,024 from a robot that doubles and will not stop by itself, so you press Stop when the number says 512 — and thirty-two more after them (boxes inside boxes, more zeros, the door code 77 from powers of two, this year from the same powers, a half, a million, letters on pads and letters poured into words, the seconds in a year, fractions, scales by hand, and robots: one moves stuck numbers across, one counts the post, one grows a box you have to stop, and several that weigh what they make against a number in a scale and stop by themselves, a team of two that leaves the smaller of two stuck fractions in the pan, and a team of four that sorts three) — are in examples/puzzles/, one file each. To make your own, read MAKING-PUZZLES.md in that folder: a puzzle is a world file with a few extra fields, built in the workshop or written with the helpers in make_puzzles.py.

The notebook, saving and sharing

The notebook on your table is a two-page spread. Drop anything on a blank page to file it; click a filed entry to take out a copy (the page keeps its own). Drop a written pad on a full page to open the first page mentioning that text; a whole number jumps to that page number. Only Dusty can remove an entry (and Undo puts it back). He will not vacuum your own notebook at all, and clicking it makes it wobble where it stands rather than lifting it — so its corner tabs stay within reach.

The spine is a grip of its own: click the leather binding and you pick up the notebook itself rather than what is lying on its pages. That is also the one hold Dusty accepts on a notebook that still has entries in it — point him anywhere else and he asks for two blank pages first. The ← and → keys turn the pages while you point at a notebook, and so do the gold corner tabs. The first page holds a blank notebook — copy it out to make more. The desk notebook remembers everything between visits, and it is yours, not the world's: it stays when you load somebody else's world, because it is your library, not part of theirs. Pick it up to move it where you like — out to the yard too — resize it in your hand with + and −, or have Dusty vacuum it up for a while; he gives it back. It remembers its place and its size along with its pages. If a world you open puts one of its things where the notebook sits, the notebook steps aside to the nearest clear spot rather than lying under it, and goes back to your place in a world that leaves it room.

It is kept under your name. The workshop asks who is working here when it opens, with the last name already filled in, and each name has a notebook of its own — so two people sharing a browser do not share a library. The line under the title says whose notebook is on the desk; click it to hand the desk to somebody else. A copy of a notebook is wholly its own from the moment it leaves the copier: filing in one never shows up in the other.

Robots can use it too, which is what lets one program use another by name. A robot fetches a blank pad, writes a name on it, drops it on the notebook — which opens at whatever that name finds — and takes a copy off the page. That is the whole of the module system: the same three gestures you would make yourself.

That lookup is by name — the robot asks for “the notebook on the desk” wherever it runs, which is what makes a program portable. If instead you train it on a notebook it was given (or one sitting on its own work area), the step names that notebook, and the robot reads that one and no other, whatever is open on the desk at the time.

Ctrl+C with a robot, a team, a box or another thing in your hand copies it to the clipboard as text, and Ctrl+V with an empty hand takes such a copy back into your hand, so a team can travel between two workshops.

Save held thing writes whatever is in your hand to a file — a box, a trained robot, a room with a whole workshop inside. Save world writes everything. Import file (or dropping a file onto the app) brings either back: things land in your hand, worlds replace the workshop.

Example worlds

Finished programs live in the examples folder. The examples gallery (also in the ⋮ menu) lays them out in the order to learn them — what each teaches, what it needs first, a picture, how to run it, and one thing to change and predict — and opens any of them in the workshop with Start this world over on the card. Or download one and use Import file. Five are ports of Ken Kahn's own ToonTalk 3 programs, move for move.

Each example is a file in the examples folder, and the file name is worth knowing — it is what you will be looking at in the folder, and what to call it when asking Marty: sentence-generator, fibonacci and fibonacci-recursive, bank-account, grammar, account (Sally's), swap, factorial, n-to-1 (the counting-down one), append and reverse.

Three more folders hold sets of their own. infinity/ is all eight Exploring Infinity activities, ending with Cantor's diagonal — a team of three robots that counts its way to the nth term of the nth sequence, because a robot can say “hole 1 of what it was given” but never “the nth one” — and Resort Infinity, Hilbert's hotel out in the yard, where you are the clerk and making room means the whole row of cottages shuffling up. sounds/ is tones (where a sound comes from), transforms (×2, ×½ and ×−1) and melody, a robot that knows no notes singing a queue of numbers into a C major scale, a note a round. images/ is pictures, album (a notebook with pictures on its pages), and naming — six robots whose thoughts hold six pictures, so the dispatch is the matching and there is no table of names anywhere.

The sentence factory (sentence-generator.world.json). A glass room called the Scriptorium holds a team of twenty robots that roll dice to pick words, join pads into sentences, and hand each one to a bird who flies it out to a nest on your table. Pull the room's lever and the nest fills with lines like "the frog dreams of the witch." Every mechanism in it is one from this manual: dice for the choice, team matching for the branch, pads for the words, a bird for the stream.

Fibonacci (fibonacci.world.json and fibonacci-recursive.world.json). Two of them: one that counts the leaves of the call tree, and one written exactly as the definition reads — answer 1 for 1 and 2, otherwise ask fib(n−1) and fib(n−2) and answer their sum, with each call getting its own house, its own nest and its own bird to reply on. A robot facing a bare nest simply dozes, so waiting for two answers needs no machinery at all. The leaf-counting one works like this: given a box holding a number, it drops a −1 on the number, copies its own box through Mimi twice, builds two rooms, puts a copy of itself in each, and carries both houses away in its own box — the two recursive calls. The robots that reach 1 or 2 mail a single 1 to a shared nest, so counting the letters counts the leaves of the call tree: for 8, twenty-one of them, from forty rooms nested six deep. A second robot then adds the pile up.

The bank account (bank-account.world.json). The account sits on the Teller's desk inside a house, so nothing on the table can reach the balance — the only way in is to send a request to the bird. A request is a box holding an amount and a bird to reply to. The Teller weighs what the balance would be against nothing at all: tipping left or level he banks it and sends the new balance home with the request's own bird; tipping right he sends a "not enough money" slip instead. The scale is the whole decision, and also the whole state — with no scale on the desk only the robot that takes a request can match, and with one there only the three verdicts can.

The grammar (grammar.world.json). The sentence factory again, except the robots know nothing about nouns or verbs: the grammar is a dictionary box on the desk. A symbol is a word (a pad, said as it stands) or a rule (a number, looked up); each rule keeps its alternatives and a die with one face per alternative. Four robots run any language you write in those boxes — one splits the next symbol off the front, one joins a word onto the sentence, one expands a rule by splitting the dictionary at that number and throwing its die, and one sends the finished sentence off when nothing is left to say. Because the noun-phrase rule mentions itself, adjectives pile up: "pink silly big big boys kick silly silly dogs." Walk in through the door, edit the dictionary, and the language changes — no robot is retrained, because none of them ever knew it.

Sally's account (account.world.json). The same idea as the bank, but open on the table so you can see the whole of it, and message-driven: the account is [Requests, Balance, Owner] and the first hole is a nest. Drop a message like ["withdraw", 30] on the bird marked requests and she carries it there; the robot whose thought carries that word wakes, lifts the message off, does it, and dozes again — so the nest is bare between messages and the team waits. The dispatch is nothing but the pattern matching, and because the owner's name is in every thought, these robots serve Sally's account and no other.

Swap, and factorial (swap.world.json, factorial.world.json). Two programs where a balance does the thinking. Swap is the smallest program here: its thought is "a scale leaning left", and it puts the two numbers the other way round — after which the scale leans the other way and it stops, because its thought no longer matches. Factorial is the same idea kept running: you hand the team [N, a bird] and the first robot builds the rest in front of you — a scale with 1 in one pan and N in the other, and "so far" joined onto the left of its own box. Then one robot counts up while the scale leans, and another answers when it comes level. Nothing counts rounds; the scale is the only test.

Lists: counting down, append, reverse — the counting-down one is n-to-1.world.json, then append.world.json and reverse.world.json. A list is the pair [first, the rest], a box with no holes is the empty list, and "the rest" is usually a nest — an answer that has not arrived yet. Counting down hands its list over one link at a time, keeping each new nest's bird so the next link lands inside the promise it just gave away. Append does the same to join two lists, which is why it keeps working when its first list is still being computed elsewhere. Reverse is the showpiece: for every link it sends a box and a copy of the append team into a house of its own, and each house dozes — smoking gently — until the nest it is watching fills. The last link is settled first, and the answer unwinds from the end of the list back to the front.