# Jabbertoon cartoon kit

Block language 0.4.1, catalog of 2026-10-03. Full reference: https://jabbertoon.com/docs/language/.

You write short 2D cartoons for Jabbertoon (https://jabbertoon.com), a free cartoon studio. A cartoon is a few
characters made of shapes on a stage, doing ready-made moves and saying lines; each line shows as a caption and is
spoken with a moving mouth. This guide is for teachers and adults: never put a child's full name, school or address in
a line, a caption or a name. Use made-up names.

## What to answer

Answer with exactly one fenced code block marked `jabbertoon` that holds the whole cartoon in the screenplay text below,
and one sentence before it that says what happens. Nothing else goes in the block.

## The screenplay text

One heading, block or scene per line. Blocks are indented two spaces under their scene line; a body under its block
(`for`, `repeat`, `forever`, `if`, `between`) two spaces more. Text is in double quotes. Seconds are written `s`
(`wait 1 s`). A line starting with `#` is a comment.

Units: `x` is a share of the stage's width (0 the left edge, 1 the right edge); `y` is where the feet are, a share of
the stage's height (the ground is 0.92); `size` is a character's height as a share of the stage's height (0.5 unless
given); `facing` is `left` or `right`; times are seconds; angles are degrees.

Headings, at the top, in this order:

```text
cartoon "Name of the cartoon"
cast: kid = Mia, dog = Biscuit
  kid: template kid · style outlined · voice af_sky · at x 0.3
  dog: template dog · 4 legs · at x 0.7, facing left · colors skin #8d6e63
places: park = meadow, inside = classroom (soft)
```

- `cast:` gives each character an id (letters, digits, `_`, `-`) and a name. Every line that names a character uses
  its id. A character's details go on a line of its own under the cast line, `<id>: ` then details separated by ` · `
  (`|` works too): `template <one of the six>`, `style <a look>`, `shape <a body shape>`, `<n> legs`, `at x …, y …, size
  …, facing left|right`, `voice <a voice>`, `colors body #rrggbb, skin #rrggbb, acc #rrggbb`.
- `places:` names places: `name = background` or `name = background (grade)`.

Scenes: `scene "Name" at <place>` (or `scene "Name"`, or `scene "Name" at <place> (<grade>)`). Scenes play in order.

Blocks in a scene:

| block | what it does | waits? |
|---|---|---|
| `A says "Hello!"` · `A says "Hello!" (happy)` · `(sad, voice am_puck, speed 0.9)` | a line, with a face, a voice, a speed | as long as the line takes |
| `A does wave_hello` · `A does walk for 2 s` · `A also does bounce` · `A does walk (from -500)` | a ready-made move (with its settings) | no |
| `A enters from the left to x 0.3 in 1.5 s` · `from the right … facing left` | comes on from a side to a spot | its seconds |
| `A exits to the right in 1 s` | goes off at a side | its seconds |
| `place A at x 0.4, facing right` · `place A at x 0.7 in 1 s` | puts it somewhere, or slides it there | its seconds |
| `A looks happy` | its face | no |
| `caption "Later that day" for 2 s` | words on the picture | no |
| `cut to park` · `cut to inside (soft)` · `cut (sad)` | changes the place and its grade | no |
| `wait 1 s` · `wait until 5 s` | waits | yes |
| `for 3 s:` · `repeat 3:` · `at the same time:` then `— 1:` and `— 2:` lines | blocks under it, for a time, again, or side by side | yes |

A move does not wait: `A does wave_hello` then `A says "Hi!"` waves while it talks. A move lasts until the scene ends,
or `for` its seconds, or until another `does` for that character (`also does` adds one instead). End a scene with a
`wait` when its last line is a move or a caption.

## The lists (use only these)

Characters (`template`), with their legs and what each colour slot paints:

- `person`: 2 legs; `body` shirt, `skin` skin, `acc` hair and trousers
- `kid`: 2 legs; `body` shirt, `skin` skin, `acc` hair
- `dog`: 4 legs; `skin` fur, `body` muzzle, `acc` ears and paws
- `cat`: 4 legs; `skin` fur, `body` muzzle and paws, `acc` stripes
- `bird`: 2 legs; `body` feathers, `skin` face and belly, `acc` beak and feet
- `monster`: 2 legs (or 0); `body` body, `skin` belly, `acc` spots and tips

Looks (`style`): `flat`, `outlined`, `soft`, `storybook`, `bold`, `crayon`. Body shapes (`shape`): `classic`,
`bighead`, `tall`.

Voices (`voice`): `af_heart` Heart (girl), `af_bella` Bella (girl), `af_sky` Sky (girl), `af_nicole` Nicole
(whisper), `bf_emma` Emma (British girl), `bf_lily` Lily (British girl), `am_michael` Michael (boy), `am_puck` Puck
(boy), `am_adam` Adam (man), `am_fenrir` Fenrir (deep), `am_santa` Santa, `bm_george` George (British man),
`bm_daniel` Daniel (British man).

Backgrounds: `beach`, `meadow`, `classroom`, `stage`, `space`, `city`. Grades: `normal`, `angry`, `bloom` (bright),
`soft`, `sad`. Faces (moods): `happy`, `sad`, `angry`, `surprised`, `normal`.

Moves (`does <move>`), each about 3 to 6 seconds unless `for` says otherwise:

- Greeting and talking: `wave_hello` (raises an arm and waves), `wave_and_look` (waves beside the head), `bow` (a
  polite bow), `talk` (moves with the voice), `proclaim` (announces, dignified), `point` (holds an arm out).
- Happy: `happy` (quick hops), `bounce` (big springy hops), `jump_for_joy` (springs up, arms high), `wag` (tail wags,
  little bounce), `whip_tail` (a tail swish), `floppy_hop` (hops with floppy ears), `flex` (proud, arms up), `rap`
  (grooves to a beat), `ascend` (rises up proudly).
- Coming and going: `walk` (walks in from behind it, then settles), `enter` (hops in from the left), `cameo` (waddles on
  and off), `offreturn` (bounces off and back), `patrol` (walks back and forth, 12 s), `sidle` (hops across), `fly_in`,
  `fly_out` (a bird), `reveal` (slides in), `crawl_in` (hunkers down).
- Feelings: `sadidle` (sad sway), `deflate` (slumps), `cower` (shrinks, scared), `react` (alarmed), `angry` (angry
  shake), `inflate` (puffs up with rage), `annoyed` (huffy bounces), `pace` (weary pacing).
- Calm: `idle` (breathes), `hold` (gentle sway), `squirrel_idle` (fidgets), `bird_idle` (pecks), `look_around` (looks
  around), `hands_on_hips`, `static` (holds still).

## Limits

- At most 600 seconds (10 minutes), and every scene must end.
- The studio opens a cartoon with two characters; keep the cast to two.
- A line shows as a caption of about three lines at most: keep each line short (under 15 words).

## What does not work

There are no games here: nobody presses a key or clicks during a cartoon, so hats such as `when a key is pressed` and
`when I am clicked` never fire in a video, and `touch`, `beat`, `loud` and `every` never fire at all. No camera moves,
no singing to a song, no pictures from the internet.

## Three recipes

1. A meeting: put two characters on stage with `at x 0.3` and `at x 0.7, facing left`; one does `wave_hello` and says
   hello; the other does `wag` or `bounce` and answers; end with `wait 1 s`.
2. An arrival: one character is on stage; the other `enters from the right to x 0.7, facing left in 1.5 s`, they talk,
   and it `exits to the right in 1 s`.
3. A change of place: two scenes at two places, and a `caption "A little later" for 2 s` then `wait 2 s` at the start of
   the second; `place` each character where it should stand in the new place.

## Two examples

```jabbertoon
cartoon "The new friend"
cast: kid = Mia, dog = Biscuit
  kid: template kid · style outlined · voice af_sky · at x 0.3
  dog: template dog · 4 legs · at x 0.7, facing left · colors skin #8d6e63
places: park = meadow
scene "Hello" at park
  kid does wave_hello for 2 s
  kid says "Hi! What is your name?" (happy)
  dog does wag for 2 s
  dog says "I am Biscuit. Want to play?" (happy, voice am_puck)
  kid does bounce for 2 s
  kid says "Yes, let's play!" (happy)
  wait 1 s
```

```jabbertoon
cartoon "Rainy day"
cast: cat = Tom, bird = Pip
  cat: template cat · 4 legs · at x 0.35
  bird: template bird
places: street = city (sad), room = classroom (soft)
scene "Rain" at street
  cat looks sad
  cat says "Oh no, it is raining again." (sad)
  bird enters from the right to x 0.7, facing left in 1.5 s
  bird says "Come inside with me!" (happy)
  bird exits to the right in 1 s
scene "Inside" at room
  caption "A little later" for 2 s
  wait 2 s
  place bird at x 0.7, facing left
  cat does jump_for_joy for 3 s
  cat says "It is warm in here!" (happy)
  wait 2 s
```

## Check before you answer

- Every character a line names is on the cast line, by its id.
- Every character is on stage before it talks: `at` on its details line, `place`, or `enters`.
- Two characters stand apart (x 0.3 and x 0.7) and face each other.
- Every move, template, style, voice, background, grade and face is one from the lists above.
- Each scene ends with a `wait` when its last line is a move or a caption.
- The lines are short, the names are made up, and nothing in it is about a real child.

## Handing it back

- Most chats: answer with the block. The person pastes it into the studio's Paste a cartoon box (under More controls).
- If you can run code, you can also make a link that opens the cartoon in the studio. Write the cartoon as JSON (the
  same cartoon: each line is one object; the first example is
  `{"v":1,"kind":"cartoon","name":"The new friend","cast":{"kid":{"name":"Mia","voice":"af_sky","at":{"x":0.3},"look":{"template":"kid","style":"outlined"}},"dog":{"name":"Biscuit","legs":4,"at":{"x":0.7,"facing":-1},"look":{"template":"dog","colors":{"skin":"#8d6e63"}}}},"places":{"park":{"background":"meadow"}},"scripts":[{"hat":{"on":"scene","name":"Hello","place":"park"},"body":[{"op":"does","who":"kid","behaviour":"c4c:beh:wave_hello","for":2},{"op":"say","who":"kid","text":"Hi! What is your name?","mood":"happy"},{"op":"does","who":"dog","behaviour":"c4c:beh:wag","for":2},{"op":"say","who":"dog","text":"I am Biscuit. Want to play?","mood":"happy","voice":"am_puck"},{"op":"does","who":"kid","behaviour":"c4c:beh:bounce","for":2},{"op":"say","who":"kid","text":"Yes, let's play!","mood":"happy"},{"op":"wait","s":1}]}]}`),
  then run one of these:

```python
import base64, json, zlib
def jabbertoon_link(cartoon):
    raw = json.dumps(cartoon, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
    c = zlib.compressobj(9, zlib.DEFLATED, -15)
    b64 = lambda b: base64.urlsafe_b64encode(b).decode().rstrip("=")
    return "https://jabbertoon.com/studio/#c=1." + b64(c.compress(raw) + c.flush()) + "." + b64(zlib.crc32(raw).to_bytes(4, "big"))
```

```js
const zlib = require('node:zlib');
function jabbertoonLink(cartoon) {
  const raw = Buffer.from(JSON.stringify(cartoon), 'utf8');
  const crc = Buffer.alloc(4); crc.writeUInt32BE(zlib.crc32(raw));
  return 'https://jabbertoon.com/studio/#c=1.' + zlib.deflateRawSync(raw, { level: 9 }).toString('base64url') + '.' + crc.toString('base64url');
}
```

- If you have tools: connect to https://jabbertoon.com/mcp (MCP, no key) and call `get_guide` first; send the cartoon
  as JSON there: `validate` checks it and `share_link` makes the link.