manic — the manual

manic is a declarative language for visual explanation. You write a readable text file; Manic turns it into a smooth, deterministic animation. No timeline scrubbing and no hand-managed keyframes — you describe the objects, the relationships, and the story beats while the engine handles motion, continuity, layout, rendering, and repeatable output.

Manic powers visual explanations, animated lessons, simulations, technical diagrams, and creator-ready videos from one readable language. Use it for mathematics, olympiad geometry, calculus, linear algebra, statistics, probability, algorithms and data structures; physics and optics; machine learning and transformer internals; systems architecture and flowcharts; fractals, tilings, fields, and particle processes; SVG artwork and bundled assets; narrated lessons; or polished Reels and Shorts. The same language moves naturally between responsive 2D, textbook-style spatial diagrams, and genuine 3D scenes.

The vocabulary is broad, but the mental model stays deliberately small enough for a non-programmer to read: name what exists, state what it depends on, and describe what should happen. Creators can begin with a circle and a caption, then keep the same model as they progress to live proofs, simulations, neural networks, or cinematic 3D stories.

Manic was created by Anish Nath. Follow its development, examples, and new visual-language experiments on X: @anish2good.

Looking for the website, browser workspace, API, extension, or source code? They are collected on the Manic links page.

The whole idea in 30 seconds

A manic file has two parts:

1. The cast — the shapes on screen (a circle, a line, some text). You give each one a name.
2. The script — what happens over time, called out by name: draw this, move that, flash it green.

title("Hello");
canvas("16:9");

circle(sun, (640, 360), 90);   // the cast: a circle named `sun`
color(sun, cyan);

show(sun, 0.6);                 // the script: fade it in over 0.6s
pulse(sun);                     // then give it a little pulse

That’s the entire model. The rest of this guide builds outward from it—first ordinary shapes and motion, then reactive relationships, creator production, specialist kits, systems, simulations, and 3D. The complete generated vocabulary is available in the API reference.

How to read this book

Every section has a runnable sample and a short video of it playing, so you see exactly what each word does. Copy any sample into a .manic file and:

manic yourfile.manic              # live preview window
manic yourfile.manic --record out # render to out/out.mp4

Ready? Start with your first animation →

Making vertical social content? Take the production path directly: Create a polished Reel →

Choosing the visual surface? Manic defaults to full semantic colour on an exact black canvas; compare every option in Templates →.

Manic links

Everything public about Manic, collected in one place.

For browser-based creation, start with Manic Create. For automated workflows, create a scoped key in Manic Account, then use the interactive API reference.

Install Manic

Manic is a compiled desktop command-line application. The installer includes the engine and its reviewed runtime assets; video export also needs ffmpeg.

macOS — Homebrew

This is the simplest macOS installation:

brew install --cask maniclang-x/tap/manic
manic version

Homebrew installs ffmpeg as a dependency and makes manic available on your PATH.

macOS or Linux — installer

The installer detects the operating system and CPU, downloads the current release, verifies its SHA-256 checksum, and installs under ~/.local:

curl -fsSL https://raw.githubusercontent.com/maniclang-x/manic/main/install.sh | sh

If needed, add Manic to your shell path:

export PATH="$HOME/.local/bin:$PATH"

Put that line in ~/.zshrc or ~/.bashrc to keep it after opening a new terminal.

Windows — PowerShell

irm https://raw.githubusercontent.com/maniclang-x/manic/main/install.ps1 | iex

Open a new terminal after installation. Install ffmpeg separately and make sure ffmpeg.exe is on PATH before exporting video or GIF files.

Linux server or container

Live preview needs a display. The Linux archive includes a helper for Ubuntu and EC2 that installs Xvfb, software OpenGL, ffmpeg, and headless audio support:

sudo bash /usr/local/share/manic/setup/ubuntu-headless.sh
manic-render story.manic --record out

If the archive was installed under ~/.local, use the corresponding helper under ~/.local/share/manic/setup/.

Confirm the installation

manic version
manic status
manic check story.manic

check parses and validates without opening a window or consuming a preview.

Connect a Manic account

You can try Manic before signing in. Connect the installation when you want it to use your account’s preview and export balance:

manic login
manic status

Verify that the confirmation code in the browser matches the terminal. Manic source files are rendered locally; ordinary licence accounting does not upload the story source.

Upgrade

Homebrew:

brew update
brew upgrade --cask manic

Installer users can rerun the installation command. A normal reinstall should keep ~/.manic, which holds this device’s installation identity and offline accounting state.

For platform-specific prerequisites, manual archives, and security warnings, see the public installation reference and troubleshooting guide.

Next: use the Manic command line →

Command-line guide

The Manic CLI follows one short loop: check → preview → export.

manic check story.manic
manic story.manic
manic story.manic --record out

The last command writes out/out.mp4 and timing markers under out/.

Everyday commands

The Workbench UI

manic ui opens the Manic Workbench — a local, browser-based studio for your .manic projects. It’s a friendlier front-end to the same engine you drive from the command line:

• Files — browse, create, rename, duplicate, and delete stories, edited in a Monaco editor with syntax help, live diagnostics, and autosave.
• Preview & render — one-click preview, and MP4 / animated GIF / PNG-frame exports with live progress and a render history under the project’s .manic-output folder.
• AI drafting (optional) — describe a story and get a draft, with diff-before-apply and a built-in manic check. Nothing leaves your machine unless you enable a provider and add your own key.

manic ui                     # open the current folder
manic ui path/to/project     # open a specific project folder

It runs entirely on your machine, on a loopback-only address with a session token, and points the Workbench at this manic binary and its bundled assets automatically — no flags needed. Use Open folder… in the UI to switch projects without restarting.

Requirements. The Workbench is fetched and run with npx, so it needs Node.js 22 or newer (npm and npx come with it); FFmpeg on your PATH is needed for MP4/GIF export. Verify with:

node -v    # v22.x or newer
npm -v
npx -v

If Node is missing or too old, manic ui prints a short install guide for your operating system instead of launching — install Node.js 22+, reopen your terminal, and run it again.

Render one part of a story

Named stages make long explainers fast to review:

manic stages lesson.manic
manic lesson.manic --stage proof
manic lesson.manic --from-stage setup --to-stage result --record review

You can also select a time range:

manic lesson.manic --from 4.0 --to 9.5 --record excerpt

Canvas and quality

manic story.manic --canvas portrait
manic story.manic --record out --fps 30
manic story.manic --record out --scale 1.25

The default studio preset records at 60 FPS. Useful presets are:

• studio — full-quality branded MP4, the default;
• reel — full-quality social/vertical output;
• test — fast 30 FPS verification;
• farm — 30 FPS headless/software-rendering output.

Choose one explicitly:

manic story.manic --record out --preset reel
xvfb-run -a manic story.manic --record out --preset farm

xvfb-run provides a virtual display; it does not change Manic’s FPS.

Account and offline commands

manic login
manic status
manic sync
manic logout

• status shows the authoritative online balance when connected and reachable.
• sync refreshes grants and reconciles completed offline work.
• logout uses browser confirmation before disconnecting the installation.

Preview runs and successful exports are separate allowances. manic check, validation failures, and failed display setup consume neither.

Deterministic variations

Generated scenes use deterministic seeds by default. Reproduce or vary them:

manic story.manic --seed 42
manic story.manic --seed random

Where files and assets live

The standard runtime asset catalogue ships beside the executable. Ordinary installs do not need MANIC_ASSETS_DIR. Set it only when intentionally replacing the entire bundled asset root:

export MANIC_ASSETS_DIR=/absolute/path/to/custom/assets

Now create the first scene: Getting started →

Getting started

Let’s make the smallest real animation: a title fades in, a circle draws itself, and it pulses once.

Here primarily for vertical social video? Jump to Create a polished Reel, the complete Creator Kit workflow. Then use Reactive stories to keep equations, plots, diagrams, and captions synchronized across each explanation beat. Want spoken narration? See Voice — optional, one voice(...) plus speak("…") lines.

// getting started — one shape, drawn on, then a pulse.
title("Hello, manic");
canvas("16:9");

text(head, (cx, 140), "hello, manic");
color(head, cyan);  size(head, 40);  hidden(head);

circle(sun, (cx, cy), 110);
color(sun, magenta);  stroke(sun, 5);  glow(sun, 8);  untraced(sun);

show(head, 0.5);      // fade the title in
draw(sun, 1.2);       // trace the circle on
pulse(sun);           // a friendly pulse
wait(1.0);

▶ See it play:

What each line is doing

There is no template(...) line in this first sample, so it uses the full-colour black template automatically. See Templates when you want mono, paper, blueprint, terminal, or a tinted surface.

Two things worth internalising right away:

• cx, cy are the canvas centre. manic gives you w, h, cx, cy for free so you can place things without hard-coding pixels. (cx, cy) is always the middle.
• The order of the cast doesn’t matter, but the script runs top-to-bottom. show, then draw, then pulse play one after another. To make things happen at the same time, you wrap them in par { … } — that’s the Timing chapter.

Two ways to appear

Notice head uses hidden + show, but sun uses untraced + draw. That’s the one gotcha worth learning early:

• hidden + show → a fade-in (good for text and filled shapes).
• untraced + draw → a draw-on, like a pen tracing the outline (good for strokes, lines, plots).

Get those two pairs right and everything else clicks. Next: the shapes you can put on screen →

Shapes — the cast

Everything on screen is an entity with a name (its first argument). You declare shapes once; the name is how you address them later in the script.

The six primitives

Each line below is the whole call — copy it and tweak the numbers.

Plus composites: polygon / sector / annulus / pie (filled by default), arc / brace / ellipse (stroke only), and boolean regions (union / intersect / …).

▶ See it play: SHAPECRAFT — fill vs outlined, the cast, palette → become, spin-wound morph, a disc that splits into four colours → reunites → moves, and two-colour booleans.

Ordinary text is portable and shaped automatically

text, say, captions, labels, and kit-generated words use Manic’s embedded font engine. No machine font is consulted, and there is no font-selection DSL: choose only the semantic mono, bold, or display look. Manic handles fallback, ligatures, combining marks, bidirectional order, wrapping, reveal, rotation, glow, camera zoom, and recording from one shaped layout.

Arabic and Devanagari are bundled script examples, so these work unchanged in preview, backend recording, and the browser build:

text(arabic, (cx, 300), "التعلّم يجعل الأفكار واضحة");
text(hindi,  (cx, 420), "ज्ञान से प्रकाश मिलता है");

Use equation or inline $…$ for mathematical typesetting. Run manic check before rendering; an unsupported Unicode cluster names the entity and code point instead of silently drawing a replacement box. Colour emoji remains intentionally unsupported until colour-font rendering is portable.

Plus a few composite helpers built from those: polygon, arc/sector, brace/ bracelabel, caption (a row of words), and support(id, (cx,cy), [len], ["dir"]) — the hatched wall / ceiling / floor for mechanics & textbook diagrams ("dir" is the open side: "down" ceiling, "up" floor, "left"/"right" walls).

Two more helpers cover scenes that would otherwise need dozens of manual dots and endpoints:

circle(glass, (400,300), 100);
particles(bubbles, glass, 24, 5, 7); // default random layout

rect(tank, (750,300), 180, 160);
particles(samples, tank, 24, 4, 11, "grid");
link(pipe, glass, tank, 35);         // 35 px of curve; 0 is straight

circle(orbit, (980,300), 90);
particles(ticks, orbit, 24, 4, 13, "ring");

particles works inside circles and rectangles. Its bare id addresses every child dot, so hidden(bubbles) and recolor(bubbles, fg) affect the whole group. Use the optional "grid" layout for an ordered rectangular state, then arrange(samples, tank, "random", 2, smooth) to move the same dots into a typical random state. arrange may target a larger container for expansion and can return to "grid" exactly. A circle plus "ring" gives the particles an ordered radial endpoint. link meets shapes at their boundaries and stays attached when either endpoint moves.

Points are (x, y) in pixels, origin top-left, y increasing downward. Use cx, cy, w, h to stay canvas-independent.

For display mathematics, equation accepts LaTeX in backticks. Standard \textcolor can emphasize individual terms with Manic’s semantic palette; the colors automatically follow the selected template:

equation(step, (cx, 620),
  `\textcolor{magenta}{\mathrm{slope}}=
   \frac{\textcolor{cyan}{\mathrm{rise}}}
        {\textcolor{gold}{\mathrm{run}}}`, 40);

Leave a term uncolored to use the template foreground. A single-color equation can still be styled as one entity with color and animated with recolor.

For a derivation, keep that same equation id and animate only the change:

rewrite(step, `\mathrm{slope}=\frac{\mathrm{rise}}{\mathrm{run}}`, 0.9, smooth);
rewrite(step, `\mathrm{slope}=\frac{x}{1}`, 0.9, smooth);

Manic matches the rendered LaTeX parts; it does not perform algebra. This makes the verb generic across algebra, calculus, physics, sums, fractions, radicals, and creator scenes while keeping each settled formula exact.

// the six primitive shapes, drawn on together.
title("Shapes");
canvas("16:9");

text(t, (cx, 90), "six primitives");  color(t, cyan);  size(t, 32);  hidden(t);

circle(c, (240, 380), 80);            color(c, cyan);     stroke(c, 4);  untraced(c);
rect(r,   (470, 380), 150, 150);      color(r, magenta);  stroke(r, 4);  untraced(r);
line(l,   (640, 300), (820, 460));    color(l, lime);     stroke(l, 4);  untraced(l);
arrow(a,  (900, 460), (1040, 300));   color(a, cyan);     stroke(a, 4);  untraced(a);
dot(d,    (1110, 380), 12);           color(d, magenta);  hidden(d);
text(lbl, (640, 620), "circle · rect · line · arrow · dot · text");
color(lbl, dim);  size(lbl, 24);  hidden(lbl);

show(t, 0.5);
par { draw(c);  draw(r);  draw(l);  draw(a);  show(d); }
show(lbl, 0.5);
wait(1.2);

▶ See it play:

Modifiers — style a shape at t = 0

A shape starts plain. Modifiers change how it looks before the animation begins. They take the entity name first, then a value:

Textbook diagrams: prefer outlined (or a thin arc) for angle marks and “regions of interest.” A filled disc or sector sitting on top of axes and construction lines hides what’s underneath — even at low opacity. Reserve solid fills for backdrop wells behind the diagram, not overlays.

circle defaults to filled + outlined, with a soft slate rim (#9AA6C9) that reads cleanly over axes. For math constructions always pair outlined(id) — outline(id, color) alone only recolors the rim and leaves the fill on. Contact points that land on crossings should be open / dashed rings (outlined + dashed), not dot — a solid marker paints over the intersection you are trying to show.

A shape owns its fill and its rim separately. color(id, c) sets the fill, outline(id, c) sets the rim, and opacity can target one layer: opacity(id, 0.4, fill) gives a translucent interior under a crisp rim — a filled shape you can still see the construction through — while opacity(id, v, stroke) fades just the rim. On a hollow shape (outlined) the fill is off, so colour the visible ring with outline, not color. (Paths — line, arrow, ellipse — are stroke-only: color sets their stroke and there is no fill layer.)

And two that decide how a shape first appears:

Colours are a fixed palette: fg, void, cyan, magenta, lime, gold, red, orange, blue, teal, violet, coral, indigo, mint, dim, panel. For a computed colour (say, one per item in a loop) use hue(id, degrees). More in Colour & style.

Naming things in a loop

When you make many shapes with a for loop, give each a unique name with interpolation — {expr} glued to the name:

for i in 0..5 {
  dot(p{i}, (200 + i*180, cy), 8);   // p0, p1, p2, p3, p4
}

That’s your cast. Now let’s make it move → Verbs.

Verbs — bringing it to life

Verbs are the script. Each one names an entity and animates it. They run top-to-bottom, one after another (use par for simultaneous).

Almost every verb takes two optional trailing arguments:

move(sun, (900, 400), 0.8, smooth);
//                     ^dur  ^easing

• [dur] — how long, in seconds (there’s a sensible default).
• [ease] — the motion curve: linear, smooth, in, out, back, bounce, elastic, spring (see Colour & style).

Reveal & hide

draw(sun, 1.2);   // -> trace a stroke on (needs `untraced` first)
erase(sun);       // -> the reverse: un-draw it
show(cap, 0.5);   // -> fade in (needs `hidden` first)
fade(cap);        // -> fade out
type(cap);        // -> typewriter: reveal text character by character

Attention

flash(sun, cyan);  // -> flash to a colour, then restore
pulse(sun);        // -> quick grow-and-settle "look here"
shake(sun);        // -> horizontal shake, an "error/no" gesture
spin(sun, 360);    // -> spin about its centre

Motion

move(p,  (900, 400));   // -> glide to an absolute point
shift(p, (0, -120));    // -> move by a delta (relative)
scale(r, 1.4);          // -> animate uniform scale to 1.4x
rotate(r, 45);          // -> rotate by 45 degrees
grow(arrow, (500, 200));// -> animate a line/arrow endpoint (draws or retargets)
cycle(x, y, z, 0.8, 90, smooth); // -> x→y→z→x along arcs

cycle(a, b, c, …, [dur], [arc], [ease]) moves every entity into the next one’s position and the last into the first. The path arc is in degrees and defaults to 90; pass 0 for straight paths. Repeated calls compose, making it useful for symbol rearrangements, card carousels, and CyclicReplace-style moves.

Relationship motion

Three verbs cover motion that would otherwise require many coordinated keyframes:

attach(label, marker, (0,-36));       // label follows marker
travel(marker, route, 2, smooth);
become(marker, nodeBlueprint, 0.8);   // same id, new visual state
attach(label, none);                  // release at the settled position
turn(nodeGroup, marker, 20, 0.6, out);// shared group pivot

attach is persistent until released. become interpolates compatible shapes and safely crossfades other pairs, always settling on the exact declared blueprint. turn accepts one entity or a tag and rotates its members around a point or entity pivot. See Motion graphics for the full design rules and a copyable V2 Reel.

Ambient motion and path flow

particles(bubbles, glass, 24, 5, 7);
link(pipe, glass, tank, 35);
untraced(pipe);

par {
  wander(bubbles, 6);              // always stays inside glass
  seq { draw(pipe); flow(pipe, 1); }
}

wander is deterministic: the same optional particle seed gives the same placement and motion in preview and in the final recording. It occupies the duration you give it, so run it in par with the story it should accompany. flow sends a temporary luminous pulse over any line, arrow, curve, spline, arc, or tracked link; it is useful for a signal, energy, traffic, or simply directing attention.

travel(marker, path, dur, smooth) moves the actual marker once along that same kind of path and leaves it at the endpoint. Use flow for temporary emphasis and travel when object identity and the stopping point matter:

plot(curve, (180,620), 90, 140, "1-exp(-x)", (0,4));
dot(marker, (180,620), 7);
par { draw(curve, 2, out); travel(marker, curve, 2, out); }

For a persistent layout change, keep the same particle ids:

rect(chamber, (540,500), 600, 260);
particles(gas, chamber, 48, 5, 17, "grid");
arrange(gas, chamber, "random", 2.5, smooth);
arrange(gas, chamber, "grid", 2.5, smooth); // exact ordered return

circle(orbit, (900,500), 150);
arrange(gas, orbit, "ring", 1.2, smooth);    // move and stop radially

arrange also accepts a different circle/rectangle container, which makes a free expansion readable without moving every dot by hand. A random layout uses independent seeded curved routes: the result is reproducible and scrubbable, but does not look like every particle followed the same ruler.

For a complete creator-oriented treatment of persistent motion, arrival, settling, and the difference between travel and flow, see Motion graphics — move ideas, not layers.

For shape continuity, morph(a,b) preserves topology: graph/line paths remain open, while circles and other closed outlines remain closed. This prevents an unwanted diagonal chord when a plot becomes a connector or guide line.

For a persistent comparison style, use dashed(id, [dash], [gap]) before the timeline. It is a base Manic modifier—not a calculus feature—so the same 16/10-pixel default pattern works on a plot, guide line, link, arrow, curve, spline, coil, or plain arc. Increase both values for a calmer large-format dash; keep the gap smaller than the dash when the curve must remain easy to follow.

Content & colour

say(cap, "next step");     // -> crossfade a text entity to new words
recolor(sun, lime, 0.5);   // -> permanently animate the colour

Rewrite an equation without rebuilding it

Declare one real LaTeX equation, then supply each mathematically correct state:

equation(work, (cx, 300), `x^2+2x=3`, 54);
rewrite(work, `x^2+2x+1=4`, 0.9, smooth);
rewrite(work, `(x+1)^2=4`, 0.9, smooth);
rewrite(work, `x=-1\pm2`, 0.9, smooth);

rewrite is visual, not a computer-algebra system: it never invents or verifies a step. Equal RaTeX parts retain identity and travel smoothly. Matching respects reading order, coarse layout roles—main line, exponent, numerator, denominator, fraction rule, and other structure—and RaTeX math-style depth. An identical character therefore cannot change mathematical jobs or jump between levels of a nested exponent. This also protects logarithm bases, operator limits, and derivative orders. If one side gains or loses fraction, radical, or grouping structure, that side leaves before the replacement enters while the compatible side and equality remain continuous. Globally incompatible states, such as a matrix becoming a compact formula, use a staged whole-equation dissolve with only a short, dim overlap. When unmatched source and target glyphs are a replacement, the old glyph leaves before the new one becomes readable; pure additions still enter immediately. Semantic \textcolor roles follow the authored formula, and the final frame is always the exact target LaTeX. No flag or alternate verb is required. Keep one equation id for the whole derivation, write readable steps, and use wait between them when the viewer needs time to absorb a result.

For a plot or diagram that changes with the same step, place rewrite and the related motion in par. Existing equations are unaffected unless this verb is used.

The escape hatch — to / set

Named verbs are shortcuts. to animates any single property, for whatever isn’t pre-named:

to(sun, opacity, 0.3, 0.5);   // animate opacity to 0.3 over 0.5s
to(sun, rot, 90);             // rotation to 90 degrees

Properties: pos, color, opacity, scale, rot, trace, hue.

Move the camera

cam((300, 200), 1.0);   // pan the camera centre
zoom(1.6, 0.8);         // zoom to 1.6x

The camera moves the whole world, so a caption or counter would slide off with it. Mark it sticky(id) to pin it to the screen and keep it readable through the move.

One verb, a whole group

If a name refers to a tag (a group) instead of a single entity, the verb runs on every member at once. This is how you animate a whole graph, table, or loop-generated set in one line:

hidden(g.nodes);     // every node, at t=0
draw(g.edges);       // trace every edge on together
flash(a.cells, cyan);// flash all array cells

More on grouping in the Kits chapter. Next, control when things happen → Timing.

Timing — flow, named phases & clocks

By default, verbs play one after another. Three wrappers change that — they turn “then, then, then” into “together” or “cascading”.

show(a);  show(b);              // a, THEN b
par    { show(a);  show(b); }   // a and b together
stagger(0.1) { show(a); show(b); show(c); }  // a, then b 0.1s later, then c…

Put a for loop inside one and it just works — the loop expands first, so all its statements land in the wrapper:

par          { for i in 0..6 { show(a{i}); } }   // whole row at once
stagger(0.1) { for i in 0..6 { show(b{i}); } }   // whole row cascading

// the same reveal, three ways: sequence, together, cascade.
title("Timing");  canvas("16:9");
text(t, (cx, 110), "seq  ·  par  ·  stagger");  color(t, cyan);  size(t, 30);  hidden(t);

for i in 0..6 { dot(a{i}, (220 + i*160, 300), 16);  color(a{i}, cyan);     hidden(a{i}); }
for i in 0..6 { dot(b{i}, (220 + i*160, 470), 16);  color(b{i}, magenta);  hidden(b{i}); }

show(t, 0.5);

// top row, all at the same instant
par { for i in 0..6 { show(a{i}); } }
wait(0.5);

// bottom row, cascading 0.1s apart
stagger(0.1) { for i in 0..6 { show(b{i}); } }
wait(1.0);

▶ See it play:

Beats & sections

Two more timing words structure a longer video:

wait(1.2);              // hold — nothing moves for 1.2s
section("Part Two");    // a titled marker (jump to it in preview with keys 1–9;
                        //   also exported for lining up narration)
mark("beat-3");         // a named timestamp for your editor

wait is your friend for pacing — a beat of stillness after something lands reads far better than rushing to the next move.

Named reactive steps

Use step when a beat represents the world’s next conceptual state, not just anonymous timing. Its children start together like par; its duration is the longest child; anything not mentioned remains exactly as it was. The unique name is written to markers.json and becomes a first-class editing boundary: manic stages FILE.manic lists durations, --stage NAME previews or records one stage, and --from-stage / --to-stage export an inclusive arc.

step("explain") {
  rewrite(work, `f'(x)=2x`, 0.9, smooth);
  to(tangent, x, 2.5, 2.0, smooth);
  to(slopeValue, x, 2.5, 2.0, smooth);
  say(caption, "Every representation changes together.");
}

Steps are top-level and names must be non-empty and unique. Put seq { … } inside a step when a small part needs ordered choreography.

An authored wait after a step remains part of that stage until the next step begins. This lets a stage-only export keep the reading hold after its motion. See Story stages for the live navigator and publishing workflow.

Generic Timing v2 — one clock for any scene

Use a generic timing controller when several parts of a scene must share one exact schedule. It is format-neutral: the same controller can coordinate a physics simulation, geometry proof, chart, caption sequence, or ordinary shapes.

Think of it as four small pieces:

The phase declaration is the source of truth. The clock is only one visual view of that choreography.

Quick reference

Core pattern, after defining the referenced entities and simulation:

timing(clock, (1160,80), "intro=1 demo=6 result=2");
timerstyle(clock, "look=ring number=inside color=cyan");

timed(clock) {
  during("intro")  { show(title, 0.6); }
  during("demo")   { par { run(sim, 6); draw(sim.path, 6); } }
  during("result") { show(answer, 0.6); }
}

Use countdown when you only need an independent visual countdown. Use timing when named phases must govern other animation.

Compose inside phases

Each during block accepts the usual timeline language. In particular, use par for actions that must occupy the same phase together:

timing(clock, "setup=1 experiment=6 result=2");

timed(clock) {
  during("setup") { show(title, 0.6); }

  during("experiment") {
    par {
      run(pendulum, 6);
      draw(pendulum.path, 6);
      karaoke(caption, 0.35);
    }
  }

  during("result") {
    par {
      show(formula, 0.6);
      show(explanation, 0.6);
    }
    wait(1.4);
  }
}

Rules that prevent drift

• Give a generic controller a fresh id. Do not reuse an entity, quiz, simulation, or group id.
• Put constructors and style modifiers outside timed/during; put timeline actions such as show, draw, run, wait, par, and seq inside.
• A short phase block is padded automatically. A block that exceeds its phase is an error.
• A phase may have at most one during block. Combine related work inside it with par or seq.
• An omitted phase is valid and becomes a blank hold.
• Phase blocks may appear in any source order: they are placed at the absolute offsets declared by timing.
• timed(clock) already runs the clock. Do not also call run(clock) inside it.
• run(clock) is timer-only playback. run(clock, dur) is rejected because the phase declaration already owns the duration.

Choose the clock’s look

The clock uses native manic shapes, so it stays sharp at any output size and can be targeted like the rest of the scene. No SVG workflow is required.

The main controls are:

• number=inside|outside|none and direction=fill|drain
• size=small|medium|large|0.5..2.0 and thickness=0.4..3.0
• color, track, label, and font=mono|display
• finish=fade|hold|flash|pulse for the completion cue

Start with the default ring, then change the look only when it supports the scene’s meaning. For legibility, keep strong contrast between color and track, and avoid combining a busy clock with dense content in the same corner.

Advanced styling can target the stable tags clock.timer, clock.timer.track, clock.timer.progress, clock.timer.value, clock.timer.label, and clock.timer.effects (replace clock with the controller id).

Generic controller or Creator quiz?

The same visual clock system serves two different timing contracts:

• timing(fresh_id, "phase=seconds ...") creates a generic controller used by timed and during.
• timing(quiz_id, "calm ask=... think=... reveal=...") configures a Creator quiz and is played with run(quiz_id).

Do not wrap a quiz in timed; the quiz runner already owns its ask, options, think, reveal, hold, and stagger phases.

Common fixes

Complete non-quiz example using a pendulum, caption, formula, and segmented clock:

// Generic Timing v2 — one named clock coordinates a non-quiz physics scene.
// `timed` runs the visual timer and places every `during` block at the exact
// offset declared by `timing`; short blocks are padded, overruns are errors.
title("Generic Timing v2 — Pendulum");
canvas("16:9");
template("mono");
watermark(manicMark, (w*0.955-100, h*0.045+24), "Made With Manic");

text(head, (315, 72), "ONE CLOCK. EVERY BEAT.");
size(head, 30); bold(head); color(head, fg); hidden(head);
text(sub, (315, 112), "Generic Timing v2 — not a quiz");
size(sub, 18); color(sub, dim); hidden(sub);

pendulum(p, (640, 245), 1.5, 42, 140, 0.03);
untraced(p.path);

equation(law, (640, 602), `T\approx2\pi\sqrt{L/g}`, 54);
color(law, gold); hidden(law);
text(note, (640, 655), "The scene and clock share the same named phases.");
size(note, 21); color(note, dim); hidden(note);
text(done, (640, 680), "INTRO  →  EXPERIMENT  →  INSIGHT  →  OUTRO");
size(done, 18); color(done, cyan); hidden(done);

// A fresh id creates a format-neutral timing controller. Its phases total
// 10.4 seconds; no duplicate duration is passed to `timed` or `run`.
timing(showclock, (970, 86), "intro=1.2 experiment=6 insight=2 outro=1.2");
timerstyle(showclock,
           "look=segments number=outside direction=drain size=small thickness=1.15 color=cyan track=dim label=MASTER_CLOCK font=display finish=pulse");

timed(showclock) {
  during("intro") {
    par { show(head, 0.7); show(sub, 0.7); }
  }

  during("experiment") {
    par { run(p, 6); draw(p.path, 6); }
  }

  during("insight") {
    par { show(law, 0.6); show(note, 0.6); }
    pulse(p.bob, 0.7);
  }

  during("outro") {
    show(done, 0.6);
  }
}

Next: the palette, glow, and easings → Colour & style.

Colour & style

The palette

manic uses a small set of semantic colour names. The default black template shows their full hues on an exact black canvas. Choose mono when the scene should communicate through black-and-white luminance instead. The semantic roles are:

Aliases: pink/accent → magenta · green → lime · yellow/amber → gold · purple → violet · turquoise → teal · salmon → coral · seafoam → mint · azure → blue · crimson → red · gray/grey → dim · white → fg · bg → void.

color(sun, cyan);
recolor(sun, magenta, 0.5);   // animate to a new palette colour

Any colour, by hue

For a computed colour — one per item in a loop — use hue, which takes an angle from 0 to 360:

hue(sun, 200);              // a fixed hue
for i in 0..24 {
  hue(p{i}, 360*i/24);      // a full rainbow around the loop
}

That’s how the rainbow-ring loop gets its colours.

Gradient paint — computed, not painted

For a colour that reads a quantity, use gradient. One word covers multi-stop ramps on fills and strokes; the mode (optional) picks the truth:

gradient(wave, blue, cyan, gold, 270);   // height of a plot
gradient(path, magenta, cyan);           // arc length along a stroke
gradient(well, panel, void, radial);     // centre → edge on a fill
gradient(p.path, blue, cyan, gold, "speed");      // true local speed (physics traj.)
gradient(swoop, dim, magenta, "curvature");       // how hard a path bends

Stops are palette names (≥2, evenly spaced) and stay template-aware. "speed" only works on pre-simulated physics trajectories; "curvature" works on any path. See the Modifiers table in Shapes, and the demos gradient, gradient-fastest-descent, and the shorts gradient-fastest-descent-shorts / gradient-pendulum-shorts.

Glow

Every entity has a neon glow (0 = crisp, higher = brighter halo):

glow(sun, 8);   // strong halo
glow(grid, 0);  // crisp, no halo — good for fine detail

Easings

The optional last argument of a motion verb is the easing — the shape of the motion over time:

move(p, (900, 400), 0.8, bounce);
move(p, (900, 400), 0.8, smooth);   // usually what you want

Canvas & size

canvas(...) sets the frame. Give it a preset or explicit pixels:

canvas("16:9");        // 1280x720  (also: 4:5, square, portrait/9:16, 4:3, 1080p, 4k)
canvas(1280, 720);     // explicit

portrait / 9:16 is 1080×1920 — pair it with the reel render preset for vertical / social clips.

Use --canvas portrait|4:5|square|16:9|WIDTHxHEIGHT to reframe one responsive source without changing its canvas(...) line. The override is applied before w, h, cx, cy, and build-time layout branches are evaluated.

Templates — the whole look

For the complete selection guide, CLI override rules, mono tips and a runnable black-and-white example, see Templates — choose the whole visual system.

template("...") sets the movie’s look in one call: the background, how the palette renders, the glow, and any page chrome. Put it near the top, after canvas(...).

canvas("16:9");
template("paper");     // a flat white exam-paper page

Omitting template(...) is exactly the same as selecting template("black"). Use mono deliberately for grayscale and plain for the original tinted neon surface.

The clever part is the palette remap: a template doesn’t just change the background, it re-maps every named palette colour to that template’s role. So on mono, cyan, magenta, lime, gold, red, orange, and blue become carefully separated greys; on paper, panel → light box, fg → dark ink, lime → forest green, and so on — which means your existing scene renders legibly on the new page without recolouring anything. That’s why template("paper") alone turns a pulley, a spring, or a linked list into a clean textbook figure (see Elevating a scene). paper/blueprint also drop the glow for crisp print output.

hue(...) and future explicit RGB colours are intentionally bespoke, so they pass through instead of being forced to greyscale. Use the named palette colours when a scene must remain strictly monochrome.

Next: loops, variables, and macros → The language layer.

Templates — choose the whole visual system

A template controls the background, semantic palette, glow character and any page chrome for the entire movie. Choose it once near the top of the file:

canvas("9:16");
template("black");

black is the default. If a DSL file does not call template(...), it renders exactly as if template("black") had been written. Keeping the call explicit is useful in shared examples; omitting it is convenient for ordinary authoring.

Available templates

Useful aliases are monochrome, blackwhite, black-white, and bw for mono; blank and clean for plain; light and print for paper; and blue for blueprint.

black and plain are intentionally different. black is a truly black, chrome-free creator canvas; plain retains Manic’s original indigo-black neon surface.

Mono in practice

// Mono is the default; keep this line explicit when teaching or sharing.
title("Mono template");
canvas("16:9");
template("mono");

rect(card, (640, 360), 930, 430);
color(card, panel);

text(head, (640, 205), "ONE PALETTE · CLEAR HIERARCHY");
size(head, 42);
color(head, fg);
hidden(head);

circle(a, (410, 370), 58); color(a, cyan); hidden(a);
circle(b, (640, 370), 58); color(b, magenta); hidden(b);
circle(c, (870, 370), 58); color(c, lime); hidden(c);

text(al, (410, 470), "PRIMARY"); color(al, fg); hidden(al);
text(bl, (640, 470), "SECONDARY"); color(bl, dim); hidden(bl);
text(cl, (870, 470), "SUCCESS"); color(cl, lime); hidden(cl);

show(head, 0.4);
par {
  show(a, 0.5);
  show(b, 0.5);
  show(c, 0.5);
}
par {
  show(al, 0.35);
  show(bl, 0.35);
  show(cl, 0.35);
}
pulse(c);
wait(1);

Named colours remain meaningful under mono. fg, dim, panel, cyan, magenta, lime, gold, red, orange, blue, teal, violet, coral, indigo, and mint are mapped to deliberately different greys instead of collapsing to identical white. This preserves hierarchy and correct-answer contrast while keeping the export monochrome.

Use named colours for template-aware work:

color(answer, lime);       // success role; becomes a bright mono tone
color(note, dim);          // secondary role; remains visually quiet

hue(...) is intentionally an explicit colour choice and bypasses semantic palette remapping. Avoid it when the output must remain strictly black and white.

DSL selection versus export override

The DSL call travels with the scene. The command-line option is useful for a one-off alternate render:

manic scene.manic --still 4.0
manic scene.manic --record out --template paper

An explicit --template NAME export option overrides the DSL template for that run. This is a quick way to proof the same semantic scene on mono, paper and blueprint without editing the source.

Creator and Reel guidance

Start with black when colour is part of the explanation. It gives Creator stories a clean, cinema-dark canvas while preserving semantic accents:

canvas("9:16");
// template("black") is optional because black is the default.
creator(me, "@anish2good yt=zarigatongy x=@anish2good web=maniclang.com footer=social");
quiz(q, "Which statement is true?");

Choose mono for an intentionally black-and-white identity, shorts for a tinted studio surface, or paper for an exam-sheet or textbook treatment. Template choice does not change Creator layout, safe areas, timing, option labels or social-platform selection—it changes only their visual system.

Practical checks

• Review one reading frame and one reveal frame at phone size.
• On black, inspect dim lines and labels as well as bright accents.
• In mono, check luminance contrast rather than relying on colour names.
• Prefer one semantic accent role; do not make every object equally bright.
• Use plain when you specifically want the original indigo-neon surface.
• Use paper or blueprint to test whether a construction remains legible on a very different surface.

Next: Colour, glow and semantic roles →

The language layer

Everything so far has been static text. manic also has a small computation layer that runs before the animation — variables, arithmetic, loops, and macros. It lets one rule draw a hundred shapes.

These are resolved at build time. By the time the animation plays, they’ve expanded into plain calls — so they cost nothing at render.

Variables — let

let r = 120;
let gap = r * 2 + 40;
circle(a, (cx - gap, cy), r);
circle(b, (cx + gap, cy), r);

Arithmetic is what you’d expect: + - * / ^, parentheses, and functions like sin, cos, sqrt. Constants pi, tau, e are built in, as are the canvas vars w, h, cx, cy.

Put a * between names. A number can hug a name (2r, 3(x+1)), but two names glued together read as one word — write r*x, i*dx, pi*t, never rx / idx / pit. This is the most common slip in loops and formulas.

Loops — for

for i in 0..5 {
  dot(p{i}, (200 + i*180, cy), 8);   // p0 … p4
}

p{i} is id interpolation — {expr} glued to a name makes each entity unique. Use i in the body to compute positions, sizes, hues…

// one for-loop paints a full rainbow ring.
title("One loop");  canvas("16:9");
text(t, (cx, 90), "one loop, 24 dots, every hue");  color(t, cyan);  size(t, 28);  hidden(t);

let n = 24;
for i in 0..n {
  dot(p{i}, (cx + 300*cos(tau*i/n), cy + 300*sin(tau*i/n)), 14);
  hue(p{i}, 360*i/n);      // colour by angle -> a rainbow
  hidden(p{i});
}

show(t, 0.5);
stagger(0.05) { for i in 0..n { show(p{i}); } }
wait(1.4);

▶ See it play:

Conditionals — if

let n = 5;
if n > 3 {
  circle(big, (cx, cy), 120);
}

Macros — def

A def is a reusable rule. Its parameters are numbers; build ids inside with interpolation. It can even call itself (recursion) — that’s how the fractal tree in the gallery is one page of code:

def branch(k, x, y, ang, len, depth) {
  if depth > 0 && len > 2 {
    let x2 = x + len*cos(ang);
    let y2 = y - len*sin(ang);
    line(seg{k}, (x, y), (x2, y2));
    branch(2*k,     x2, y2, ang + 0.4, len*0.72, depth - 1);
    branch(2*k + 1, x2, y2, ang - 0.4, len*0.72, depth - 1);
  }
}
branch(1, cx, h - 40, 1.5708, 150, 12);

Curve L-systems — one rule, one path

For deterministic textbook curves, use lsystem instead of manually recursing into thousands of separate lines:

lsystem(carpet, (cx,cy), 620,
  "F+F+F+F",
  "F=FF+F+F+F+FF",
  "angle=90 heading=0 iterations=4");

gradient(carpet, cyan, magenta, gold);
stroke(carpet, 2);
untraced(carpet);
draw(carpet, 3, smooth);

The six arguments are:

1. id, centre, and fitted square size;
2. the starting string (axiom);
3. semicolon-separated rewrite rules such as "X=...;Y=...";
4. one short options string.

In the generated program, + turns left by angle, - turns right, | turns around, and every symbol listed by draw=F moves forward while drawing. heading sets the first direction, iterations controls detail, and padding keeps the result away from its fitted edge.

Use closed=true fill=true when the grammar describes a closed boundary; Manic triangulates it into one concave region. Keep fill=false for line curves. The constructor deliberately does not interpret branch brackets: use a recursive def or tree3 for branching plants. This separation keeps curve stories simple and makes invalid input easy to repair.

Practical tips

• Increase iterations one step at a time: rewrite systems grow exponentially.
• Keep the curve as one entity, then use ordinary draw, gradient, move, become, step, and camera verbs.
• For a lesson, show generations 0 → 1 → 2 before revealing the detailed curve.
• See lsystem-asymptote-curves.manic for four canonical grammars and creator-lsystem-fractal-curve.manic for a complete creator Short.

Repeated motifs — one design, many placements

Use repeat when the visual idea is “this motif forms a field,” not “write a loop that manually copies every part.”

polygon(tile, (cx-12,cy+10), (cx+12,cy+10), (cx,cy-14));
repeat(field, tile, "layout=hex rings=4 spacing=42 rotate=30 scale=0.8");
untraced(field);
draw(field, 2, smooth);

The motif can be one entity or a tag containing several entities. Choose:

• layout=hex rings=N spacing=S;
• layout=grid rows=R cols=C spacing=S (or separate gapx / gapy);
• layout=radial count=N radius=R face=same|out.

rotate turns the arrangement and scale sizes each instance. Every output is tagged with the destination id; stable instances are {id}.i0, {id}.i1, … The output of one repeat can itself be the motif of another, which is how nested textbook tilings stay short. Use normal color, gradient, mask, untraced, draw, and stagger afterward.

See asymptote-tiling-reference.manic for hex/grid/radial/nested coverage and creator-one-tile-pattern-story.manic for the creator treatment.

Reductions

Fold a range into one number with sum, prod, min, max:

let n = 6;
let total = sum(i in 1..n : i);   // 1 + 2 + … + (n-1)

That’s the whole language. The rest is kits — bundles of higher-level figures → Kits.

Bundled assets — portable files without path guessing

Manic scenes can use small, documented production assets through a stable asset: URI. The URI works from the desktop CLI, a different working directory, the Docker image, or the production backend. No render flag is needed.

image(mark, (cx, 260), "asset:manic-logo.png", 180, 180);
model3(beacon, "asset:models/manic-pyramid.obj", (0,0,0), 1);
assembly3(console, "asset:models/manic-console.obj", (3,0,0), 1);
svg(logo, (cx, 480), "asset:svg/heart.svg", 320);

The same image URI can be used in a Creator profile:

creator(me, "@anish2good name=Manic logo=asset:manic-logo.png footer=signature");
socials(me);

Available public assets

The SVG sets are a curated, permissively-licensed starter pack (see assets/svg/LICENSES.md). List what’s bundled — and what a file imports as — with manic svgcheck assets/svg.

The catalog stays deliberately small. Do not invent an asset name that is not listed here. Manic reports a clear error if a bundled URI is missing, and it rejects .. traversal. OBJ files also retain the normal file-size and geometry safety limits.

Vector import — SVG as native geometry

svg() brings vector artwork in as native path entities — not a texture. Each subpath of the SVG becomes a real Polyline/Polygon you can draw, morph, recolour, and animate exactly like a shape you authored by hand. It’s the 2D twin of model3’s OBJ import.

svg(logo, (cx, cy), "asset:svg/heart.svg", 320);

Reposition — the second argument is the centre. Move it, or animate it; every piece follows because the whole drawing shares one tag:

svg(pin, (cx, cy), "asset:svg/pin.svg", 200);   // centred at (cx, cy)
move(pin, (cx, cy - 200), 1.0);                  // glide the whole drawing up

Resize — the last argument is the width in pixels; the height follows the artwork’s own aspect ratio:

svg(small, (300, cy), "asset:svg/robot.svg", 120);   // 120 px wide
svg(big,   (800, cy), "asset:svg/robot.svg", 360);   // same file, 3× bigger — still crisp

Recolour — imported fills reproduce faithfully (they are not re-themed by the template, even if a colour happens to match a palette name). Change them whenever you like:

recolor(logo, cyan);            // whole drawing → cyan
hue(logo, 200, 0.9, 0.6);       // …or by HSL
gradient(logo, gold, magenta);  // …or a gradient across it

Animate — one verb drives the whole drawing (it is tagged with the id):

hidden(logo); show(logo, 0.8);  // reveal
pulse(logo, 0.9);               // emphasise

Address one piece — subpaths are named {id}.p0, {id}.p1, … in document order, so you can single one out:

recolor(pin.p1, gold);   // just the pin's inner hole

Layering — imported art defaults to z = 0. Raise it above another layer (a grid, a backdrop) with z:

z(logo, 6);

What v1 imports (and what it skips)

Imported: paths plus the basic shapes (rect, circle, ellipse, line, polygon, polyline) with their transforms resolved, and solid fill/stroke colours. Curves are flattened to smooth polylines.

Imported gradients: linear and radial fill gradients come in faithfully (mapped onto Manic’s gradient(), multi-stop ramps resampled) — so gradient icons, illustrations, and emblems keep their shading.

Skipped for now: SVG <text> and embedded <image>, clipPath/mask, filters and blurs, pattern paint, and gradient strokes (fills are supported). Keep artwork reasonably simple — there’s a point-budget guard and the usual file-size limit.

Two things worth knowing:

• currentColor — most icon sets (Lucide, Heroicons, …) paint with currentColor, a host-themed placeholder. Manic imports those as themeable geometry: they take the entity’s own colour, so recolor(icon, cyan) just works. Artwork with real colours (flags, illustrations) keeps them faithfully.
• Concave fills are triangulated (ear-clipping), so stars, notched glyphs, and blobs fill correctly — not just convex shapes.

Screen a set before you rely on it

Downloaded a folder of SVGs? Vet them against the importer first:

$ manic svgcheck assets/svg/lucide
  ✓ rocket.svg — 4 paths, 199 pts, themeable (0 with fill/stroke)
  ✓ map-pin.svg — 2 paths, 147 pts, themeable (0 with fill/stroke)
  …

Each file reports its subpath/point count and whether it’s themeable (recolour it) or coloured (keeps its own colours); anything empty, over-budget, or unparseable is flagged with ✗. scripts/fetch-svg-assets.sh vendors the bundled sets the same way.

Your own images and models

Ordinary paths still work:

image(photo, (cx,cy), "uploads/my-photo.jpg", 720, 480);
model3(product, "uploads/my-product.obj", (0,0,0), 1);
svg(logo, (cx,cy), "uploads/my-logo.svg", 300);

Bring in any SVG this way — an icon you downloaded, a logo, a map outline. The caller must make those files available to the renderer. This is the right choice for uploads and private brand assets; asset: is for the small catalog that ships with Manic.

Adding a new bundled asset to Manic

1. Put it under assets/ in a typed folder such as models/, with a lowercase, descriptive filename.
2. Add its stable URI to this page and assets/README.md.
3. Add or update a checked .manic example using the URI.
4. Keep models geometry-only; do not add scripts, arbitrary shaders, or remote dependencies.
5. Run the tests and mdBook build.

The release machinery copies the entire directory. Docker installs it at /usr/local/share/manic/assets; Linux builds produce dist/manic-assets.tar.gz; the EC2 deploy installs that archive; and the playground sync mirrors the same catalog. Future entries therefore need no per-file pipeline edit. A custom deployment may point MANIC_ASSETS_DIR at a different catalog root.

SVG assets — reference & aliases

Every svg() import takes an asset:svg/<set>/<name>.svg URI (or your own file path). The bundled catalogue covers 6,404 shapes across four sets, vendored by scripts/fetch-svg-assets.sh and screened with manic svgcheck assets/svg. Licences: assets/svg/LICENSES.md.

Reference notation

svg(logo, (cx, cy), "asset:svg/lucide/rocket.svg", 300);   // an icon
svg(fin,  (cx, cy), "asset:svg/flags/in.svg",       220);   // a flag (ISO code)
svg(joy,  (cx, cy), "asset:svg/emoji/fire.svg",     140);   // an emoji (alias)
svg(joy,  (cx, cy), "asset:svg/emoji/1f525.svg",    140);   // …same, by codepoint

Themeable vs faithful. Lucide/Heroicons paint with currentColor, so they take the entity’s colour — recolor(icon, cyan) just works. Flags and emoji keep their real colours. Concave shapes (stars, emblems) fill correctly, and stroke-drawn designs (stripes, Nordic crosses) import as filled bands.

Known limitation. A few flags place their stars with SVG <use> instancing (e.g. cn — China) or <marker>; those instanced glyphs render incorrectly for now (tracked). The flag’s plain fields still show, and all icons/emoji and most flags render cleanly. svgcheck a set before you rely on it.

Emoji friendly aliases

Twemoji files are named by Unicode codepoint; these short names resolve to the same file — either works:

Any other emoji works by codepoint — e.g. asset:svg/emoji/1f680.svg (🚀). Add your own aliases in scripts/fetch-svg-assets.sh.

Discovering the full catalogue

Browse every bundled asset: the SVG asset catalogue lists all 6,400+ files by set — searchable with ⌘/Ctrl-F, no CLI needed. That page is generated from the assets themselves by scripts/gen-svg-index.py, so it always matches what ships.

If you have the CLI, svgcheck also screens a folder — and shows what each file imports as (paths, points, themeable vs coloured):

$ manic svgcheck assets/svg/lucide
  ✓ rocket.svg — 4 paths, 199 pts, themeable
  ✓ map-pin.svg — 2 paths, 147 pts, themeable
  …
$ manic svgcheck assets/svg/flags        # every country flag
$ manic svgcheck assets/svg/emoji        # every Twemoji

scripts/fetch-svg-assets.sh re-vendors or updates every set from its upstream repo (Lucide · Heroicons · flag-icons · Twemoji). Bring your own: svg(id, pos, "path/to/any.svg") imports any SVG file — vet it with svgcheck first. See the import how-to for positioning, resizing, recolouring, and animating.

SVG asset catalogue

Every one of the 6,429 bundled SVG vectors, by set — so you can find an asset without the CLI. Drop any of them in with:

svg(id, (x, y), "asset:svg/<set>/<name>.svg", size);

Names are searchable — use your browser’s find (⌘/Ctrl-F). Licences are per set; see assets/svg/LICENSES.md for full attribution. For a quick start with plain-English emoji names, see the friendly aliases.

Lucide — clean outline icons · 1,756 · ISC

asset:svg/lucide/<name>.svg

a-arrow-down · a-arrow-up · a-large-small · accessibility · activity · ad · air-vent · airplay · alarm-clock · alarm-clock-check · alarm-clock-minus · alarm-clock-off · alarm-clock-plus · alarm-smoke · album · align-center-horizontal · align-center-vertical · align-end-horizontal · align-end-vertical · align-horizontal-distribute-center · align-horizontal-distribute-end · align-horizontal-distribute-start · align-horizontal-justify-center · align-horizontal-justify-end · align-horizontal-justify-start · align-horizontal-space-around · align-horizontal-space-between · align-start-horizontal · align-start-vertical · align-vertical-distribute-center · align-vertical-distribute-end · align-vertical-distribute-start · align-vertical-justify-center · align-vertical-justify-end · align-vertical-justify-start · align-vertical-space-around · align-vertical-space-between · ambulance · ampersand · ampersands · amphora · anchor · angry · annoyed · antenna · anvil · aperture · app-window · app-window-mac · apple · archive · archive-restore · archive-x · armchair · arrow-big-down · arrow-big-down-dash · arrow-big-left · arrow-big-left-dash · arrow-big-right · arrow-big-right-dash · arrow-big-up · arrow-big-up-dash · arrow-down · arrow-down-0-1 · arrow-down-1-0 · arrow-down-a-z · arrow-down-from-line · arrow-down-left · arrow-down-narrow-wide · arrow-down-right · arrow-down-to-dot · arrow-down-to-line · arrow-down-up · arrow-down-wide-narrow · arrow-down-z-a · arrow-left · arrow-left-from-line · arrow-left-right · arrow-left-to-line · arrow-right · arrow-right-from-line · arrow-right-left · arrow-right-to-line · arrow-up · arrow-up-0-1 · arrow-up-1-0 · arrow-up-a-z · arrow-up-down · arrow-up-from-dot · arrow-up-from-line · arrow-up-left · arrow-up-narrow-wide · arrow-up-right · arrow-up-to-line · arrow-up-wide-narrow · arrow-up-z-a · arrows-up-from-line · asterisk · astroid · at-sign · atom · audio-lines · audio-waveform · award · axe · axis-3d · baby · backpack · badge · badge-alert · badge-cent · badge-check · badge-dollar-sign · badge-euro · badge-indian-rupee · badge-info · badge-japanese-yen · badge-minus · badge-percent · badge-plus · badge-pound-sterling · badge-question-mark · badge-russian-ruble · badge-swiss-franc · badge-turkish-lira · badge-x · baggage-claim · balloon · ban · banana · bandage · banknote · banknote-arrow-down · banknote-arrow-up · banknote-check · banknote-x · barcode · barrel · baseline · bath · battery · battery-charging · battery-full · battery-low · battery-medium · battery-plus · battery-warning · beaker · bean · bean-off · bed · bed-double · bed-single · beef · beef-off · beer · beer-off · bell · bell-check · bell-dot · bell-electric · bell-minus · bell-off · bell-plus · bell-ring · between-horizontal-end · between-horizontal-start · between-vertical-end · between-vertical-start · biceps-flexed · bike · binary · binoculars · biohazard · bird · birdhouse · bitcoin · blend · blender · blinds · blocks · bluetooth · bluetooth-connected · bluetooth-off · bluetooth-searching · bold · bolt · bomb · bone · bone-fracture · book · book-a · book-alert · book-audio · book-check · book-copy · book-dashed · book-down · book-headphones · book-heart · book-image · book-key · book-lock · book-marked · book-minus · book-open · book-open-check · book-open-text · book-plus · book-search · book-text · book-type · book-up · book-up-2 · book-user · book-x · bookmark · bookmark-check · bookmark-minus · bookmark-off · bookmark-plus · bookmark-x · boom-box · bot · bot-message-square · bot-off · bottle-wine · bow-arrow · box · boxes · braces · brackets · brain · brain-circuit · brain-cog · brick-wall · brick-wall-fire · brick-wall-shield · briefcase · briefcase-business · briefcase-conveyor-belt · briefcase-medical · bring-to-front · broccoli · brush · brush-cleaning · bubbles · bug · bug-off · bug-play · building · building-2 · bus · bus-front · cable · cable-car · cake · cake-slice · calculator · calendar · calendar-1 · calendar-arrow-down · calendar-arrow-up · calendar-check · calendar-check-2 · calendar-clock · calendar-cog · calendar-days · calendar-fold · calendar-heart · calendar-minus · calendar-minus-2 · calendar-off · calendar-plus · calendar-plus-2 · calendar-range · calendar-search · calendar-sync · calendar-x · calendar-x-2 · calendars · camera · camera-off · candy · candy-cane · candy-off · cannabis · cannabis-off · captions · captions-off · car · car-front · car-taxi-front · caravan · card-sim · carrot · case-lower · case-sensitive · case-upper · cassette-tape · cast · castle · cat · cctv · cctv-off · chart-area · chart-bar · chart-bar-big · chart-bar-decreasing · chart-bar-increasing · chart-bar-stacked · chart-candlestick · chart-column · chart-column-big · chart-column-decreasing · chart-column-increasing · chart-column-stacked · chart-gantt · chart-line · chart-network · chart-no-axes-column · chart-no-axes-column-decreasing · chart-no-axes-column-increasing · chart-no-axes-combined · chart-no-axes-gantt · chart-pie · chart-scatter · chart-spline · check · check-check · check-line · chef-hat · cherry · chess-bishop · chess-king · chess-knight · chess-pawn · chess-queen · chess-rook · chevron-down · chevron-first · chevron-last · chevron-left · chevron-right · chevron-up · chevrons-down · chevrons-down-up · chevrons-left · chevrons-left-right · chevrons-left-right-ellipsis · chevrons-right · chevrons-right-left · chevrons-up · chevrons-up-down · church · cigarette · cigarette-off · circle · circle-alert · circle-arrow-down · circle-arrow-left · circle-arrow-out-down-left · circle-arrow-out-down-right · circle-arrow-out-up-left · circle-arrow-out-up-right · circle-arrow-right · circle-arrow-up · circle-check · circle-check-big · circle-chevron-down · circle-chevron-left · circle-chevron-right · circle-chevron-up · circle-dashed · circle-divide · circle-dollar-sign · circle-dot · circle-dot-dashed · circle-ellipsis · circle-equal · circle-euro · circle-fading-arrow-up · circle-fading-plus · circle-gauge · circle-minus · circle-off · circle-parking · circle-parking-off · circle-pause · circle-percent · circle-pile · circle-play · circle-plus · circle-pound-sterling · circle-power · circle-question-mark · circle-slash · circle-slash-2 · circle-small · circle-star · circle-stop · circle-user · circle-user-round · circle-x · circuit-board · citrus · clapperboard · clipboard · clipboard-check · clipboard-clock · clipboard-copy · clipboard-list · clipboard-minus · clipboard-paste · clipboard-pen · clipboard-pen-line · clipboard-plus · clipboard-type · clipboard-x · clock · clock-1 · clock-10 · clock-11 · clock-12 · clock-2 · clock-3 · clock-4 · clock-5 · clock-6 · clock-7 · clock-8 · clock-9 · clock-alert · clock-arrow-down · clock-arrow-left · clock-arrow-right · clock-arrow-up · clock-check · clock-fading · clock-plus · closed-caption · cloud · cloud-alert · cloud-backup · cloud-check · cloud-cog · cloud-download · cloud-drizzle · cloud-fog · cloud-hail · cloud-lightning · cloud-moon · cloud-moon-rain · cloud-off · cloud-rain · cloud-rain-wind · cloud-snow · cloud-sun · cloud-sun-rain · cloud-sync · cloud-upload · cloudy · clover · club · code · code-xml · coffee · cog · coins · columns-2 · columns-3 · columns-3-cog · columns-4 · combine · command · compass · component · computer · concierge-bell · cone · construction · contact · contact-round · container · contrast · cookie · cooking-pot · copy · copy-check · copy-minus · copy-plus · copy-slash · copy-x · copyleft · copyright · corner-down-left · corner-down-right · corner-left-down · corner-left-up · corner-right-down · corner-right-up · corner-up-left · corner-up-right · cpu · creative-commons · credit-card · croissant · crop · cross · crosshair · crown · cuboid · cup-soda · currency · cylinder · dam · database · database-arrow-down · database-arrow-up · database-backup · database-check · database-minus · database-plus · database-search · database-x · database-zap · decimals-arrow-left · decimals-arrow-right · delete · dessert · diameter · diamond · diamond-minus · diamond-percent · diamond-plus · dice-1 · dice-2 · dice-3 · dice-4 · dice-5 · dice-6 · dices · diff · disc · disc-2 · disc-3 · disc-album · divide · dna · dna-off · dock · dog · dollar-sign · donut · door-closed · door-closed-locked · door-open · dot · download · drafting-compass · drama · drill · drone · droplet · droplet-off · droplets · drum · drumstick · dumbbell · ear · ear-off · earth · earth-lock · eclipse · egg · egg-fried · egg-off · ellipse · ellipsis · ellipsis-vertical · equal · equal-approximately · equal-not · eraser · ethernet-port · euro · ev-charger · expand · external-link · eye · eye-closed · eye-dashed · eye-off · factory · fan · fast-forward · feather · fence · ferris-wheel · file · file-archive · file-axis-3d · file-badge · file-box · file-braces · file-braces-corner · file-chart-column · file-chart-column-increasing · file-chart-line · file-chart-pie · file-check · file-check-corner · file-clock · file-code · file-code-corner · file-cog · file-diff · file-digit · file-down · file-exclamation-point · file-headphone · file-heart · file-image · file-input · file-key · file-lock · file-minus · file-minus-corner · file-music · file-output · file-pen · file-pen-line · file-play · file-plus · file-plus-corner · file-question-mark · file-scan · file-search · file-search-corner · file-signal · file-sliders · file-spreadsheet · file-stack · file-symlink · file-terminal · file-text · file-type · file-type-corner · file-up · file-user · file-video-camera · file-volume · file-x · file-x-corner · files · film · fingerprint-pattern · fire-extinguisher · fish · fish-off · fish-symbol · fishing-hook · fishing-rod · flag · flag-off · flag-triangle-left · flag-triangle-right · flame · flame-kindling · flashlight · flashlight-off · flask-conical · flask-conical-off · flask-round · flip-horizontal-2 · flip-vertical-2 · flower · flower-2 · focus · fold-horizontal · fold-vertical · folder · folder-archive · folder-bookmark · folder-check · folder-clock · folder-closed · folder-code · folder-cog · folder-dot · folder-down · folder-git · folder-git-2 · folder-heart · folder-input · folder-kanban · folder-key · folder-lock · folder-minus · folder-open · folder-open-dot · folder-output · folder-pen · folder-plus · folder-root · folder-search · folder-search-2 · folder-symlink · folder-sync · folder-tree · folder-up · folder-x · folders · footprints · forklift · form · forward · frame · frown · fuel · fullscreen · funnel · funnel-plus · funnel-x · gallery-horizontal · gallery-horizontal-end · gallery-thumbnails · gallery-vertical · gallery-vertical-end · gamepad · gamepad-2 · gamepad-directional · gauge · gavel · gem · georgian-lari · ghost · gift · git-branch · git-branch-minus · git-branch-plus · git-commit-horizontal · git-commit-vertical · git-compare · git-compare-arrows · git-fork · git-graph · git-merge · git-merge-conflict · git-pull-request · git-pull-request-arrow · git-pull-request-closed · git-pull-request-create · git-pull-request-create-arrow · git-pull-request-draft · glass-water · glasses · globe · globe-check · globe-lock · globe-off · globe-x · goal · gpu · graduation-cap · grape · grid-2x2 · grid-2x2-check · grid-2x2-plus · grid-2x2-x · grid-3x2 · grid-3x3 · grip · grip-horizontal · grip-vertical · group · guitar · ham · hamburger · hammer · hand · hand-coins · hand-fist · hand-grab · hand-heart · hand-helping · hand-metal · hand-platter · handbag · handshake · hard-drive · hard-drive-download · hard-drive-upload · hard-hat · hash · hat-glasses · haze · hd · hdmi-port · heading · heading-1 · heading-2 · heading-3 · heading-4 · heading-5 · heading-6 · headphone-off · headphones · headset · heart · heart-crack · heart-handshake · heart-minus · heart-off · heart-plus · heart-pulse · heart-x · heater · helicopter · hexagon · highlighter · hop · hop-off · hospital · hotel · hourglass · house · house-heart · house-plug · house-plus · house-wifi · ice-cream-bowl · ice-cream-cone · id-card · id-card-lanyard · image · image-down · image-minus · image-off · image-play · image-plus · image-up · image-upscale · images · import · inbox · indian-rupee · infinity · info · inspection-panel · italic · iteration-ccw · iteration-cw · japanese-yen · joystick · kanban · kayak · key · key-round · key-square · keyboard · keyboard-music · keyboard-off · lamp · lamp-ceiling · lamp-desk · lamp-floor · lamp-wall-down · lamp-wall-up · land-plot · landmark · languages · laptop · laptop-minimal · laptop-minimal-check · lasso · lasso-select · laugh · layers · layers-2 · layers-minus · layers-plus · layout-dashboard · layout-freeform · layout-grid · layout-list · layout-panel-left · layout-panel-top · layout-template · leaf · leafy-green · lectern · lens-concave · lens-convex · library · library-big · life-buoy · ligature · lightbulb · lightbulb-off · line-dot-right-horizontal · line-squiggle · line-style · link · link-2 · link-2-off · list · list-check · list-checks · list-chevrons-down-up · list-chevrons-up-down · list-collapse · list-end · list-filter · list-filter-plus · list-indent-decrease · list-indent-increase · list-minus · list-music · list-ordered · list-plus · list-restart · list-sort-ascending · list-sort-descending · list-start · list-todo · list-tree · list-video · list-x · loader · loader-circle · loader-pinwheel · locate · locate-fixed · locate-off · lock · lock-keyhole · lock-keyhole-open · lock-open · log-in · log-out · logs · lollipop · luggage · magnet · mail · mail-check · mail-minus · mail-open · mail-plus · mail-question-mark · mail-search · mail-warning · mail-x · mailbox · mails · map · map-minus · map-pin · map-pin-check · map-pin-check-inside · map-pin-house · map-pin-minus · map-pin-minus-inside · map-pin-off · map-pin-pen · map-pin-plus · map-pin-plus-inside · map-pin-search · map-pin-x · map-pin-x-inside · map-pinned · map-plus · mars · mars-stroke · martini · maximize · maximize-2 · medal · megaphone · megaphone-off · meh · memory-stick · menu · merge · message-circle · message-circle-check · message-circle-code · message-circle-dashed · message-circle-heart · message-circle-more · message-circle-off · message-circle-plus · message-circle-question-mark · message-circle-reply · message-circle-warning · message-circle-x · message-square · message-square-check · message-square-code · message-square-dashed · message-square-diff · message-square-dot · message-square-heart · message-square-lock · message-square-more · message-square-off · message-square-plus · message-square-quote · message-square-reply · message-square-share · message-square-text · message-square-warning · message-square-x · messages-square · metronome · mic · mic-audio-lines · mic-off · mic-signal · mic-vocal · microchip · microscope · microwave · milestone · milk · milk-off · minimize · minimize-2 · minus · mirror-rectangular · mirror-round · monitor · monitor-check · monitor-cloud · monitor-cog · monitor-dot · monitor-down · monitor-off · monitor-pause · monitor-play · monitor-smartphone · monitor-speaker · monitor-stop · monitor-up · monitor-x · moon · moon-star · mosque · motorbike · mountain · mountain-snow · mouse · mouse-left · mouse-off · mouse-pointer · mouse-pointer-2 · mouse-pointer-2-off · mouse-pointer-ban · mouse-pointer-click · mouse-right · move · move-3d · move-diagonal · move-diagonal-2 · move-down · move-down-left · move-down-right · move-horizontal · move-left · move-right · move-up · move-up-left · move-up-right · move-vertical · music · music-2 · music-3 · music-4 · navigation · navigation-2 · navigation-2-off · navigation-off · network · newspaper · nfc · non-binary · notebook · notebook-pen · notebook-tabs · notebook-text · notepad-text · notepad-text-dashed · nut · nut-off · octagon · octagon-alert · octagon-minus · octagon-pause · octagon-x · omega · option · orbit · origami · package · package-2 · package-check · package-minus · package-open · package-plus · package-search · package-x · paint-bucket · paint-roller · paintbrush · paintbrush-vertical · palette · panda · panel-bottom · panel-bottom-close · panel-bottom-dashed · panel-bottom-open · panel-left · panel-left-close · panel-left-dashed · panel-left-open · panel-left-right-dashed · panel-right · panel-right-close · panel-right-dashed · panel-right-open · panel-top · panel-top-bottom-dashed · panel-top-close · panel-top-dashed · panel-top-open · panels-left-bottom · panels-right-bottom · panels-top-left · paper-bag · paperclip · parasol · parentheses · parking-meter · party-popper · pause · paw-print · pc-case · pen · pen-line · pen-off · pen-tool · pencil · pencil-line · pencil-off · pencil-ruler · pencil-sparkles · pentagon · percent · person-standing · phi · philippine-peso · phone · phone-call · phone-forwarded · phone-incoming · phone-missed · phone-off · phone-outgoing · pi · piano · pickaxe · picture-in-picture · picture-in-picture-2 · piggy-bank · pilcrow · pilcrow-left · pilcrow-right · pill · pill-bottle · pin · pin-off · pipette · pizza · plane · plane-landing · plane-takeoff · play · play-off · plug · plug-2 · plug-zap · plus · pocket-knife · podium · pointer · pointer-off · popcorn · popsicle · pound-sterling · power · power-off · presentation · printer · printer-check · printer-x · projector · proportions · puzzle · pyramid · qr-code · quote · rabbit · radar · radiation · radical · radio · radio-off · radio-receiver · radio-tower · radius · rainbow · rat · ratio · receipt · receipt-cent · receipt-euro · receipt-indian-rupee · receipt-japanese-yen · receipt-pound-sterling · receipt-russian-ruble · receipt-swiss-franc · receipt-text · receipt-turkish-lira · rectangle-circle · rectangle-ellipsis · rectangle-goggles · rectangle-horizontal · rectangle-vertical · recycle · redo · redo-2 · redo-dot · refresh-ccw · refresh-ccw-dot · refresh-cw · refresh-cw-off · refrigerator · regex · remove-formatting · repeat · repeat-1 · repeat-2 · repeat-off · replace · replace-all · reply · reply-all · rewind · ribbon · road · rocket · rocking-chair · roller-coaster · rose · rotate-3d · rotate-ccw · rotate-ccw-clock · rotate-ccw-key · rotate-ccw-square · rotate-cw · rotate-cw-fading-clock · rotate-cw-square · route · route-off · router · rows-2 · rows-3 · rows-4 · rss · ruler · ruler-dimension-line · russian-ruble · sailboat · salad · sandwich · satellite · satellite-dish · saudi-riyal · save · save-all · save-check · save-off · save-pen · save-plus · scale · scale-3d · scaling · scan · scan-barcode · scan-box · scan-eye · scan-face · scan-heart · scan-line · scan-qr-code · scan-search · scan-square · scan-text · school · scissors · scissors-line-dashed · scooter · screen-share · screen-share-off · scroll · scroll-text · search · search-alert · search-check · search-code · search-slash · search-x · section · send · send-horizontal · send-to-back · separator-horizontal · separator-vertical · server · server-cog · server-crash · server-off · server-plus · settings · settings-2 · shapes · share · share-2 · sheet · shell · shelving-unit · shield · shield-alert · shield-ban · shield-check · shield-cog · shield-cog-corner · shield-ellipsis · shield-half · shield-keyhole · shield-minus · shield-off · shield-plus · shield-question-mark · shield-user · shield-x · ship · ship-wheel · shirt · shopping-bag · shopping-basket · shopping-cart · shovel · shower-head · shredder · shrimp · shrink · shrub · shuffle · sigma · signal · signal-high · signal-low · signal-medium · signal-zero · signature · signpost · signpost-big · siren · skip-back · skip-forward · skull · slash · slice · sliders-horizontal · sliders-vertical · smartphone · smartphone-charging · smartphone-nfc · smile · smile-plus · snail · snowflake · soap-dispenser-droplet · sofa · solar-panel · soup · space · spade · sparkle · sparkles · speaker · speech · spell-check · spell-check-2 · spline · spline-pointer · split · spool · sport-shoe · spotlight · spray-can · sprout · square · square-activity · square-arrow-down · square-arrow-down-left · square-arrow-down-right · square-arrow-left · square-arrow-out-down-left · square-arrow-out-down-right · square-arrow-out-up-left · square-arrow-out-up-right · square-arrow-right · square-arrow-right-enter · square-arrow-right-exit · square-arrow-up · square-arrow-up-left · square-arrow-up-right · square-asterisk · square-bottom-dashed-scissors · square-centerline-dashed-horizontal · square-centerline-dashed-vertical · square-chart-gantt · square-check · square-check-big · square-chevron-down · square-chevron-left · square-chevron-right · square-chevron-up · square-code · square-dashed · square-dashed-bottom · square-dashed-bottom-code · square-dashed-kanban · square-dashed-mouse-pointer · square-dashed-text · square-dashed-top-solid · square-divide · square-dot · square-equal · square-function · square-kanban · square-library · square-m · square-menu · square-minus · square-mouse-pointer · square-off · square-parking · square-parking-off · square-pause · square-pen · square-percent · square-pi · square-pilcrow · square-play · square-plus · square-power · square-radical · square-round-corner · square-scissors · square-sigma · square-slash · square-split-horizontal · square-split-vertical · square-square · square-stack · square-star · square-stop · square-terminal · square-user · square-user-round · square-x · squares-exclude · squares-intersect · squares-subtract · squares-unite · squircle · squircle-dashed · squirrel · stamp · star · star-check · star-half · star-minus · star-off · star-plus · star-x · step-back · step-forward · stethoscope · sticker · sticky-note · sticky-note-check · sticky-note-minus · sticky-note-off · sticky-note-plus · sticky-note-x · sticky-notes · stone · store · stretch-horizontal · stretch-vertical · strikethrough · subscript · summary · sun · sun-dim · sun-medium · sun-moon · sun-snow · sunrise · sunset · superscript · swatch-book · swiss-franc · switch-camera · sword · swords · syringe · table · table-2 · table-cells-merge · table-cells-split · table-columns-split · table-of-contents · table-properties · table-rows-split · tablet · tablet-smartphone · tablets · tag · tag-plus · tag-x · tags · tally-1 · tally-2 · tally-3 · tally-4 · tally-5 · tangent · target · telescope · tent · tent-tree · terminal · test-tube · test-tube-diagonal · test-tubes · text-align-center · text-align-end · text-align-justify · text-align-start · text-cursor · text-cursor-input · text-initial · text-quote · text-search · text-wrap · theater · thermometer · thermometer-snowflake · thermometer-sun · thumbs-down · thumbs-up · ticket · ticket-check · ticket-minus · ticket-percent · ticket-plus · ticket-slash · ticket-x · tickets · tickets-plane · timeline · timer · timer-off · timer-reset · toggle-left · toggle-right · toilet · tool-case · toolbox · tornado · torus · touchpad · touchpad-off · towel-rack · tower-control · toy-brick · tractor · traffic-cone · train-front · train-front-tunnel · train-track · tram-front · transgender · trash · trash-2 · tree-deciduous · tree-palm · tree-pine · trees · trending-down · trending-up · trending-up-down · triangle · triangle-alert · triangle-dashed · triangle-right · trophy · truck · truck-electric · turkish-lira · turntable · turtle · tv · tv-minimal · tv-minimal-play · type · type-outline · umbrella · umbrella-off · underline · undo · undo-2 · undo-dot · unfold-horizontal · unfold-vertical · ungroup · university · unlink · unlink-2 · unplug · upload · usb · user · user-check · user-cog · user-key · user-lock · user-minus · user-pen · user-plus · user-round · user-round-arrow-left · user-round-check · user-round-cog · user-round-key · user-round-minus · user-round-pen · user-round-plus · user-round-search · user-round-x · user-search · user-shield · user-star · user-x · users · users-round · utensils · utensils-crossed · utility-pole · van · variable · vault · vector-square · vegan · venetian-mask · venus · venus-and-mars · vibrate · vibrate-off · video · video-off · videotape · view · voicemail · volleyball · volume · volume-1 · volume-2 · volume-off · volume-x · vote · wallet · wallet-cards · wallet-minimal · wallpaper · wand · wand-sparkles · warehouse · washing-machine · watch · waves-arrow-down · waves-arrow-up · waves-horizontal · waves-ladder · waves-vertical · waypoints · webcam · webcam-off · webhook · webhook-off · weight · weight-tilde · wheat · wheat-off · whole-word · wifi · wifi-cog · wifi-high · wifi-low · wifi-off · wifi-pen · wifi-sync · wifi-zero · wind · wind-arrow-down · wine · wine-off · workflow · worm · wrench · wrench-off · x · x-line-top · zap · zap-off · zodiac-aquarius · zodiac-aries · zodiac-cancer · zodiac-capricorn · zodiac-gemini · zodiac-leo · zodiac-libra · zodiac-ophiuchus · zodiac-pisces · zodiac-sagittarius · zodiac-scorpio · zodiac-taurus · zodiac-virgo · zoom-in · zoom-out

Heroicons — Tailwind’s UI icon set · 324 · MIT

asset:svg/heroicons/<name>.svg

academic-cap · adjustments-horizontal · adjustments-vertical · archive-box · archive-box-arrow-down · archive-box-x-mark · arrow-down · arrow-down-circle · arrow-down-left · arrow-down-on-square · arrow-down-on-square-stack · arrow-down-right · arrow-down-tray · arrow-left · arrow-left-circle · arrow-left-end-on-rectangle · arrow-left-on-rectangle · arrow-left-start-on-rectangle · arrow-long-down · arrow-long-left · arrow-long-right · arrow-long-up · arrow-path · arrow-path-rounded-square · arrow-right · arrow-right-circle · arrow-right-end-on-rectangle · arrow-right-on-rectangle · arrow-right-start-on-rectangle · arrow-small-down · arrow-small-left · arrow-small-right · arrow-small-up · arrow-top-right-on-square · arrow-trending-down · arrow-trending-up · arrow-turn-down-left · arrow-turn-down-right · arrow-turn-left-down · arrow-turn-left-up · arrow-turn-right-down · arrow-turn-right-up · arrow-turn-up-left · arrow-turn-up-right · arrow-up · arrow-up-circle · arrow-up-left · arrow-up-on-square · arrow-up-on-square-stack · arrow-up-right · arrow-up-tray · arrow-uturn-down · arrow-uturn-left · arrow-uturn-right · arrow-uturn-up · arrows-pointing-in · arrows-pointing-out · arrows-right-left · arrows-up-down · at-symbol · backspace · backward · banknotes · bars-2 · bars-3 · bars-3-bottom-left · bars-3-bottom-right · bars-3-center-left · bars-4 · bars-arrow-down · bars-arrow-up · battery-0 · battery-100 · battery-50 · beaker · bell · bell-alert · bell-slash · bell-snooze · bold · bolt · bolt-slash · book-open · bookmark · bookmark-slash · bookmark-square · briefcase · bug-ant · building-library · building-office · building-office-2 · building-storefront · cake · calculator · calendar · calendar-date-range · calendar-days · camera · chart-bar · chart-bar-square · chart-pie · chat-bubble-bottom-center · chat-bubble-bottom-center-text · chat-bubble-left · chat-bubble-left-ellipsis · chat-bubble-left-right · chat-bubble-oval-left · chat-bubble-oval-left-ellipsis · check · check-badge · check-circle · chevron-double-down · chevron-double-left · chevron-double-right · chevron-double-up · chevron-down · chevron-left · chevron-right · chevron-up · chevron-up-down · circle-stack · clipboard · clipboard-document · clipboard-document-check · clipboard-document-list · clock · cloud · cloud-arrow-down · cloud-arrow-up · code-bracket · code-bracket-square · cog · cog-6-tooth · cog-8-tooth · command-line · computer-desktop · cpu-chip · credit-card · cube · cube-transparent · currency-bangladeshi · currency-dollar · currency-euro · currency-pound · currency-rupee · currency-yen · cursor-arrow-rays · cursor-arrow-ripple · device-phone-mobile · device-tablet · divide · document · document-arrow-down · document-arrow-up · document-chart-bar · document-check · document-currency-bangladeshi · document-currency-dollar · document-currency-euro · document-currency-pound · document-currency-rupee · document-currency-yen · document-duplicate · document-magnifying-glass · document-minus · document-plus · document-text · ellipsis-horizontal · ellipsis-horizontal-circle · ellipsis-vertical · envelope · envelope-open · equals · exclamation-circle · exclamation-triangle · eye · eye-dropper · eye-slash · face-frown · face-smile · film · finger-print · fire · flag · folder · folder-arrow-down · folder-minus · folder-open · folder-plus · forward · funnel · gif · gift · gift-top · globe-alt · globe-americas · globe-asia-australia · globe-europe-africa · h1 · h2 · h3 · hand-raised · hand-thumb-down · hand-thumb-up · hashtag · heart · home · home-modern · identification · inbox · inbox-arrow-down · inbox-stack · information-circle · italic · key · language · lifebuoy · light-bulb · link · link-slash · list-bullet · lock-closed · lock-open · magnifying-glass · magnifying-glass-circle · magnifying-glass-minus · magnifying-glass-plus · map · map-pin · megaphone · microphone · minus · minus-circle · minus-small · moon · musical-note · newspaper · no-symbol · numbered-list · paint-brush · paper-airplane · paper-clip · pause · pause-circle · pencil · pencil-square · percent-badge · phone · phone-arrow-down-left · phone-arrow-up-right · phone-x-mark · photo · play · play-circle · play-pause · plus · plus-circle · plus-small · power · presentation-chart-bar · presentation-chart-line · printer · puzzle-piece · qr-code · question-mark-circle · queue-list · radio · receipt-percent · receipt-refund · rectangle-group · rectangle-stack · rocket-launch · rss · scale · scissors · server · server-stack · share · shield-check · shield-exclamation · shopping-bag · shopping-cart · signal · signal-slash · slash · sparkles · speaker-wave · speaker-x-mark · square-2-stack · square-3-stack-3d · squares-2x2 · squares-plus · star · stop · stop-circle · strikethrough · sun · swatch · table-cells · tag · ticket · trash · trophy · truck · tv · underline · user · user-circle · user-group · user-minus · user-plus · users · variable · video-camera · video-camera-slash · view-columns · viewfinder-circle · wallet · wifi · window · wrench · wrench-screwdriver · x-circle · x-mark

Flags — country flags, two-letter ISO 3166-1 codes · 271 · MIT

asset:svg/flags/<name>.svg

ad · ae · af · ag · ai · al · am · ao · aq · ar · arab · as · asean · at · au · aw · ax · az · ba · bb · bd · be · bf · bg · bh · bi · bj · bl · bm · bn · bo · bq · br · bs · bt · bv · bw · by · bz · ca · cc · cd · cefta · cf · cg · ch · ci · ck · cl · cm · cn · co · cp · cr · cu · cv · cw · cx · cy · cz · de · dg · dj · dk · dm · do · dz · eac · ec · ee · eg · eh · er · es · es-ct · es-ga · es-pv · et · eu · fi · fj · fk · fm · fo · fr · ga · gb · gb-eng · gb-nir · gb-sct · gb-wls · gd · ge · gf · gg · gh · gi · gl · gm · gn · gp · gq · gr · gs · gt · gu · gw · gy · hk · hm · hn · hr · ht · hu · ic · id · ie · il · im · in · io · iq · ir · is · it · je · jm · jo · jp · ke · kg · kh · ki · km · kn · kp · kr · kw · ky · kz · la · lb · lc · li · lk · lr · ls · lt · lu · lv · ly · ma · mc · md · me · mf · mg · mh · mk · ml · mm · mn · mo · mp · mq · mr · ms · mt · mu · mv · mw · mx · my · mz · na · nc · ne · nf · ng · ni · nl · no · np · nr · nu · nz · om · pa · pc · pe · pf · pg · ph · pk · pl · pm · pn · pr · ps · pt · pw · py · qa · re · ro · rs · ru · rw · sa · sb · sc · sd · se · sg · sh · sh-ac · sh-hl · sh-ta · si · sj · sk · sl · sm · sn · so · sr · ss · st · sv · sx · sy · sz · tc · td · tf · tg · th · tj · tk · tl · tm · tn · to · tr · tt · tv · tw · tz · ua · ug · um · un · us · uy · uz · va · vc · ve · vg · vi · vn · vu · wf · ws · xk · xx · ye · yt · za · zm · zw

Emoji — Twemoji — full-colour emoji · 4,073 · CC-BY 4.0

asset:svg/emoji/<name>.svg

Friendly aliases (64) — plain-English names, the easy way in:

bell · brain · bulb · car · chart · check · clap · cloud · comet · computer · crescentmoon · cross · door · earth · eyes · fire · firstquarter · flag · fullmoon · glowstar · goat · grinning · heart · hourglass · joy · jupiter · key · lastquarter · lock · mail · mars · mercury · milkyway · money · moon · muscle · neptune · newmoon · party · phone · rainbow · rocket · saturn · smile · sob · star · sun · sunface · target · telescope · thinking · thumbsdown · thumbsup · trophy · uranus · venus · waningcrescent · waninggibbous · warning · wave · waxingcrescent · waxinggibbous · wink · zap

All emoji (4,009) are also addressable by their Unicode codepoint filename (e.g. 1f680 = 🚀). Expand to browse every one: