# paper-motion > Motion resources for AI agents: component transitions, transitions, text effects, camera moves, backgrounds > (Paper shaders), palettes, font pairs and video recipes, each with a name. You pick them for the user's brand, > propose options as a **board** link they open in a browser, install what they choose as code they own, and render > the video with the paper-motion engine. Nothing here renders on a server: every preview plays in the user's browser. ## The flow (for agents) 1. **Set up.** `npx skills add solanodz/paper-motion` (the skills) and `npx paper-motion setup` (the engine: Node 18+, ffmpeg, Chrome). The CLI is `npx paper-motion`; where these docs write `pamo`, type `npx paper-motion` (the npm package named `pamo` is unrelated). `npx paper-motion --version` prints the version. Every command answers `--help`. Agents load skills and MCP servers when a session starts, so after installing the skills **read `.claude/skills/make-video/SKILL.md` now** (or `.agents/skills/make-video/SKILL.md`) and follow it in this session; tell the user that the MCP at https://paper-motion.vercel.app/mcp, if they want it, is added before opening a session. 2. **Open the studio: it is where the user decides.** A video is made in stages the user watches and approves in a local page in three steps (What it says: brief and inventory; Your video; Export). Start the piece right after setup: `npx paper-motion piece init --title "…"` (it starts the project's studio in the background). Then, at the end of each stage, `npx paper-motion piece review `: the first time it opens the studio in the user's browser; it waits for their decision and prints what they did, one `paper-motion: piece …` line each (an approval, a change to make, or an edit they already made by hand: the brief, words on screen, lengths, joins, order; build on those, never undo them). Quick renders for review: `chain --drafts` (each part on its own) and `chain --draft` (joined). Only when the user can't open a browser, run the same stages in the chat. Between your turns keep `npx paper-motion piece listen ` running in the background: it returns as soon as the user needs you (a message, an answer, an approval), with lines like review's, so they never have to come back to the chat (start it again after; exit 3 means nothing in 9 minutes). Say what you are doing with `piece working --on "…"`, ask with `piece ask "…"` (they answer in the studio), and reply there with `piece say "…"`. The studio only shows what it can check about you. 3. **Interview.** Follow the `make-video` skill. Without the skills, ask at least: what the brand is in one plain line; what this video is for and where it plays (format: 16:9, 9:16, 1:1); its ground, text and accent colors or "no brand yet"; three words for the feel and one thing it must never look like; the one action at the end. Mirror it back, write it into the brief (`piece init --what … --who … --format … --tone … --action …`) and `piece review brief`. **You never choose a look for the user.** These decisions always go through a board, in this order, one board each: palette · font pair · background(s) · moves by role (how things enter, how one thing becomes the next, how text arrives; let them pick several with `choose`) · recipe or shots (shots are 3–6 s camera gestures: a close-up, a pass over a component, a cursor that clicks; they chain before a recipe or stand alone) · blocks for the moments inside it (ready-made 4–8 s pieces: annotations on a screen, a form, a terminal, code typing, a chart, captions, a logo sting; each recomposes for 16:9, 9:16 and 1:1). Skip a board only when the brand folder already settles that decision, and say so. 4. **Propose with boards.** For each visual decision (palette, type, background, moves, recipe) pick 2–4 options from this registry and share a board link: `pamo board --url --title … --option id … --look palette,font` prints it (format below): a short link (`https://paper-motion.vercel.app/b/`, stored for 90 days) when the site answers, the long form with the board in the URL fragment otherwise. The user opens it, sees the options live in their look, may tune one, and chooses. The command keeps running and prints the choice the moment they choose (10 min by default; `--no-wait` returns at once and they paste the line instead). It is one line: `paper-motion: B · mesh-sage --set speed=0.8 (bg-1)`, `paper-motion: A+C · type-on · scramble (text-1)` when the board let them pick several (`--choose 1-3`: use it for text effects and transitions), or `paper-motion: none of bg-1, calmer ones`. The reply carries every value that differs from the defaults, your pre-tuning included, so installing it reproduces what they saw. Never ask the user to paste anything while a command or the MCP is waiting: the choice arrives on its own. 5. **Install the choices.** `npx paper-motion add [--set key=value …]` in the project root, with exactly the `--set` arguments from the reply. Moves go to `moves/`, backgrounds to `brand/shader-set/set.json`, palettes and fonts to `brand/tokens.json`, recipes to `pieces//`. Their choices also accumulate in a kit at https://paper-motion.vercel.app/kit, whose prompt carries the whole `pamo add` command. `add` never overwrites a value already in the project: when the user re-chooses or re-tunes something you installed before, pass `--force`. A recipe also reads `brand/motion.json` (pace) and `brand/sound.json` (cues; without it the piece is silent) and the brand's name from `tokens.json` `brand`: write those from the interview before rendering. 6. **Make the video.** Every move the user chose appears in the piece, and the brief says where each one plays (a chosen transition may be the join between two parts of a chain: `"join": "wipe"` in chain.json takes its id); a recipe's own moves are placeholders to swap for theirs. Build `scene.html` (a pure function of time), check stills with `pamo still`, render with `pamo render scene.html --motion-blur 5`. The test shot and the final piece are real renders, not boards. When the user chose a structure whose beats name blocks or shots (or several blocks in order), chain them instead: `npx paper-motion chain init --board --option D` installs each beat's block under `pieces//-/` and writes `chain.json` (seconds per part; `join`: whip, cut, dissolve or dip); write each part's `CONFIG` from its beat, then `npx paper-motion chain --motion-blur 5` renders every part in the brand's look and joins them into one video. It warns when a part is cut before its land. In the studio the stages are brief, inventory, video and final. When the user approves the inventory the studio builds the video itself from what they kept, and then they edit it there, live (words, how each part arrives, backgrounds, settings, lengths, transitions, order, adding and swapping parts, colours, type, pace); every edit reaches you as a line. Review `video` to wait for their approval; they can render the final from the studio. `chain --check` warns when the total drifts from the brief's length. While a piece is open and its studio runs, `board --url` puts the options into the studio, on the step they decide (How it looks for palettes, type, backgrounds and moves; Your video for transitions and structures), instead of making a link; it waits there and prints the same reply line, and a palette, font pair or background the user picks is applied already. `--link` makes a link anyway. If your shell caps how long a command may run, use `--no-wait` and then `npx paper-motion board --await --wait 2` (exit code 3 = not yet). ## Choosing well: the metadata https://paper-motion.vercel.app/registry.json is the index; every item carries, beside id, type, title, summary, tags and the names of its `params` (ranges and defaults are in https://paper-motion.vercel.app/r/.json, fetch it before writing a `--set`): - `when`: 2–3 "use it when…" phrases. - `mood`: calm, bold, playful, technical, editorial, warm, minimal, luxury, raw. - Moves: `energy` 1 (still) to 5 (violent) and `role` (enter, exit, swap, emphasis, camera, text). - Blocks and shots: `needs`, the content each one shows by kind (a `figure`, a `change`, a `screen`, a `command`, a `line`…). Choose them by what the user has to show, not by mood. Gather `pieces//inventory.json` with `npx paper-motion inventory --from --from README.md --from brand` (it reads the page and screenshots it, a markdown file, a folder, or the brand's Facts and assets, and writes proposals, each with its source; `npx paper-motion inventory kinds` lists the kinds and their fields). Complete what a proposal still needs (a command's real output), add what gathering cannot see, and hand it over: `npx paper-motion piece review inventory`. The user keeps or removes each proposal in the studio; only what they kept is used. Then let `npx paper-motion plan --seconds ` propose the structures: it prints the structure board to share, and `chain init --plan ` installs the chosen one with the content already in every part's CONFIG. - Backgrounds and palettes: `colors` (dominant hex) and `mode` (light, dark); backgrounds also `motion` (still, gentle, lively). **Every background is a color family**: a board with a `look.palette` shows each background recolored into that palette (each of its colors keeps its tone and takes the nearest palette hue, so a dark one stays dark), and the reply line carries the resulting values. Without a board, `pamo add --palette ` installs it that way (`brand` reads `brand/tokens.json`). So choose backgrounds by `motion`, `mood` and texture first; the color comes from the palette. - Font pairs: `voice` (serif, sans, display, mono). Recipes, shots and blocks: `duration`, `formats` and `beats` (the structure as a timeline: name, from, to, what). A recipe board plays each structure as a sketch, so the user chooses a rhythm, not a name; you may add one option that is a **structure of your own** for this brief (`structure` instead of `id`, format below), which you then build from scratch. Give each of its beats the `id` of the block or shot that shows it: the board then plays those clips in order, so the user watches the structure instead of reading it. Give the recipe board `choose: [1, 3]`: picking several recipes in order means **one piece made of those blocks in that order**, each block's closing beat dropped except the last; the reply reads `A+C · manifesto · three-things`, and you build that sequence from scratch, using each recipe's scene as the reference for its block. `pamo search` filters by them: `pamo search --type background --mode dark --near "#0a0f1f,#eef1f8,#3d6bff"` sorts backgrounds by color fit (the mean distance from each of theirs to the nearest of yours; lower is closer; pass ground, figure and accent so resources with white type are not punished); `pamo search --type component --mood calm --energy "<=3" --role swap`. Worked example, four backgrounds for a dark cobalt brand: filter `type=background`, `mode=dark`; rank by nearest `colors` to the brand's ground, figure and accent; spread the `motion` as far as the catalog allows (a quiet one, a lively one); prefer `mood` overlapping the brand's words; tune one toward the accent (`dither-slate:colorFront=#3d6bff`); write a one-line `--note` for each; share the link. ## The MCP server The same registry as tools, with no install: add `https://paper-motion.vercel.app/mcp` (streamable HTTP, no auth) to your agent. Tools: `search` (the filters above), `resource` (one record in full), `recolor` (a background's values in a palette), `board` (creates a short link and waits for the user's choice, which it returns as `choices`) and `board_choice`. Installing is still `npx paper-motion add` in the user's project, or your own file tools from the record. ## The board link format `https://paper-motion.vercel.app/b#` where payload = base64url(deflate-raw(JSON)). The JSON: ```json { "v": 1, "kind": "resource", "title": "Backgrounds for Kiln", "ask": "Which one feels like the product?", "reply": "bg-1", "choose": 1, "look": { "palette": { "id": "cobalt", "values": {} }, "font": { "id": "geist", "values": {} } }, "options": [ { "label": "A", "id": "mesh-graphite", "values": {}, "note": "quiet, graphite" }, { "label": "B", "id": "neuro-slate", "values": {}, "note": "a technical web" }, { "label": "C", "id": "dither-slate", "values": { "colorFront": "#3d6bff" }, "note": "pixels in your accent" }, { "label": "D", "id": "grain-slate", "values": {} } ] } ``` A recipe board may hold one option that is a structure of your own for this brief; if chosen, you build it from scratch: ```json { "label": "D", "structure": { "title": "Three cuts", "duration": 18, "beats": [ { "name": "Hook", "from": 0, "to": 2, "what": "one line over the field", "id": "word-swap" }, { "name": "Proof", "from": 2, "to": 12, "what": "three shots of the product", "id": "browser-frame" }, { "name": "Close", "from": 12, "to": 18, "what": "the wordmark and the action", "id": "svg-logo" } ] } } ``` Short links: `POST https://paper-motion.vercel.app/api/boards` with `{ "board": … }` returns `{ id, url }`; `GET /api/boards//choice` answers 204 until the user chooses, then `{ line, label }`. Boards expire after 90 days; `DELETE /api/boards/` forgets one. Rules: 2–4 options, labels A–D, `choose` 1 (default), a count or `[min, max]`, one resource type per `resource` board; `kind: "kit"` makes each option `{ "label", "items": [{ "id", "values" }], "note" }` (a whole kit); `values` hold only what differs from the defaults; the JSON stays under 8 KB. `pamo board --url` builds and validates it for you. Resources by type (164 in all): ## Component transitions ### Dive in · `dive-in` The camera dives into a detail of A; B opens inside it, a ring breaks outward, B's parts rise into focus. Signature: `diveIn(a, b, p, { duration, target, depth })` Params: `duration` = 1.1 (length of the transition in seconds; springs use it to keep their feel); `target` = "[data-par" (CSS selector of the detail to dive into); `depth` = 16 (how deep the camera dives) - The camera dives into a detail of A (`target`); B opens inside it as it fills the slot, a ring breaks outward, B's parts rise into focus. - Stack A and B in one positioned slot (their parent); give the slot overflow:hidden to keep travel inside it. - Pass the real duration in seconds and call it through p = 1: that is when it hides the layers it made. - Render with --motion-blur 5. - `target` is a selector inside A (default [data-part="media"]); a round detail reads best. Install: `npx paper-motion add dive-in` · https://paper-motion.vercel.app/r/dive-in.json ```js import { diveIn } from './moves/dive-in.js'; // A and B (two states of a card) stacked in one positioned slot; 1.1 s from 2.0 s: s.update((t) => diveIn(cardA, cardB, progress(t, 2.0, 3.1), { duration: 1.1 })); ``` ### Flip lift · `flip-lift` A lifts toward the camera, flips with a wobble and a sheen, lands as B with an echo; B's parts pop in. Signature: `flipLift(a, b, p, { duration, lift, perspective })` Params: `duration` = 1.2 (length of the transition in seconds; springs use it to keep their feel); `lift` = 150 (lift toward the camera in px); `perspective` = 1800 (3D perspective in px) - A lifts toward the camera, flips with a wobble and a sheen across its face, and lands as B with an echo; B's parts pop in after. - Stack A and B in one positioned slot (their parent); give the slot overflow:hidden to keep travel inside it. - Pass the real duration in seconds and call it through p = 1: that is when it hides the layers it made. - Render with --motion-blur 5. Install: `npx paper-motion add flip-lift` · https://paper-motion.vercel.app/r/flip-lift.json ```js import { flipLift } from './moves/flip-lift.js'; // A and B (two states of a card) stacked in one positioned slot; 1.1 s from 2.0 s: s.update((t) => flipLift(cardA, cardB, progress(t, 2.0, 3.1), { duration: 1.1 })); ``` ### Magic move · `magic-move` Each part of A flies on its own spring into the matching part of B; text cross-blurs; the box reshapes. Signature: `magicMove(a, b, p, { duration, stagger, stiffness, damping })` Params: `duration` = 1.1 (length of the transition in seconds; springs use it to keep their feel); `stagger` = 0.045 (delay between parts (as a fraction of the transition)); `stiffness` = 190 (spring stiffness (higher is snappier)); `damping` = 17 (spring damping (lower bounces more)) - Magic move: parts with the same `data-part` in A and B fly from A's place and size to B's, each on its own spring, a few frames apart; text parts scale evenly and cross-blur; parts only in A leave, parts only in B pop in. The box behind (background, border, corners) reshapes from A's to B's. - Stack A and B in one positioned slot (their parent); give the slot overflow:hidden to keep travel inside it. - Pass the real duration in seconds and call it through p = 1: that is when it hides the layers it made. - Render with --motion-blur 5. - Parts match by data-part (label, title, body, meta, media…); unmatched parts leave or pop in. Install: `npx paper-motion add magic-move` · https://paper-motion.vercel.app/r/magic-move.json ```js import { magicMove } from './moves/magic-move.js'; // A and B (two states of a card) stacked in one positioned slot; 1.1 s from 2.0 s: s.update((t) => magicMove(cardA, cardB, progress(t, 2.0, 3.1), { duration: 1.1 })); ``` ### Snap scroll · `snap-scroll` A vertical reel of cards scrolls past in 3D and snaps onto B; neighbours dim and tilt away. Signature: `snapScroll(a, b, p, { duration, count, gap, perspective })` Params: `duration` = 1.2 (length of the transition in seconds; springs use it to keep their feel); `count` = 3 (number of cards in the reel); `gap` = 0.1 (gap between cards (fraction)); `perspective` = 1600 (3D perspective in px) - A vertical reel of cards (copies of A and B between them) scrolls past in 3D and snaps onto B; neighbours dim, shrink and tilt away. - Stack A and B in one positioned slot (their parent); give the slot overflow:hidden to keep travel inside it. - Pass the real duration in seconds and call it through p = 1: that is when it hides the layers it made. - Render with --motion-blur 5. - Draws live copies of the card: a Paper shader canvas inside comes out blank. Install: `npx paper-motion add snap-scroll` · https://paper-motion.vercel.app/r/snap-scroll.json ```js import { snapScroll } from './moves/snap-scroll.js'; // A and B (two states of a card) stacked in one positioned slot; 1.1 s from 2.0 s: s.update((t) => snapScroll(cardA, cardB, progress(t, 2.0, 3.1), { duration: 1.1 })); ``` ### Squash drop · `squash-drop` A squashes, launches up stretched; B falls in, squashes on impact, wobbles; its content follows through. Signature: `squashDrop(a, b, p, { duration, height })` Params: `duration` = 1.1 (length of the transition in seconds; springs use it to keep their feel); `height` = 1.3 (launch height in heights) - A squashes, then launches up stretched; B falls in stretched, squashes on impact and wobbles to rest while its content follows through. - Stack A and B in one positioned slot (their parent); give the slot overflow:hidden to keep travel inside it. - Pass the real duration in seconds and call it through p = 1: that is when it hides the layers it made. - Render with --motion-blur 5. Install: `npx paper-motion add squash-drop` · https://paper-motion.vercel.app/r/squash-drop.json ```js import { squashDrop } from './moves/squash-drop.js'; // A and B (two states of a card) stacked in one positioned slot; 1.1 s from 2.0 s: s.update((t) => squashDrop(cardA, cardB, progress(t, 2.0, 3.1), { duration: 1.1 })); ``` ### Tile swirl · `tile-swirl` A breaks into tiles that lift and swirl in a wave, flipping over in flight to land as B. Signature: `tileSwirl(a, b, p, { cols, rows, lift, perspective })` Params: `cols` = 6 (grid columns); `rows` = 4 (grid rows); `lift` = 280 (lift toward the camera in px); `perspective` = 1600 (3D perspective in px) - A breaks into tiles that lift and swirl outward in a diagonal wave, flipping over in flight, and land as B. - Stack A and B in one positioned slot (their parent); give the slot overflow:hidden to keep travel inside it. - Pass the real duration in seconds and call it through p = 1: that is when it hides the layers it made. - Render with --motion-blur 5. - Draws live copies of the card: a Paper shader canvas inside comes out blank. Install: `npx paper-motion add tile-swirl` · https://paper-motion.vercel.app/r/tile-swirl.json ```js import { tileSwirl } from './moves/tile-swirl.js'; // A and B (two states of a card) stacked in one positioned slot; 1.1 s from 2.0 s: s.update((t) => tileSwirl(cardA, cardB, progress(t, 2.0, 3.1), { duration: 1.1 })); ``` ### Unfold · `unfold` A's items leave, A folds into a glowing line, B unfolds out of the line with overshoot, items rise from it. Signature: `unfold(a, b, p, { duration, radius })` Params: `duration` = 1.2 (length of the transition in seconds; springs use it to keep their feel); `radius` = 14 (corner radius in px) - A's items leave, A folds into a glowing line, a glint runs along it, and B unfolds out of the line with overshoot as its items rise from it. - Stack A and B in one positioned slot (their parent); give the slot overflow:hidden to keep travel inside it. - Pass the real duration in seconds and call it through p = 1: that is when it hides the layers it made. - Render with --motion-blur 5. Install: `npx paper-motion add unfold` · https://paper-motion.vercel.app/r/unfold.json ```js import { unfold } from './moves/unfold.js'; // A and B (two states of a card) stacked in one positioned slot; 1.1 s from 2.0 s: s.update((t) => unfold(cardA, cardB, progress(t, 2.0, 3.1), { duration: 1.1 })); ``` ### Whip pan · `whip-pan` A winds up, whips out tilted and smeared under a light streak; B whips in, overshoots, its content trails. Signature: `whipPan(a, b, p, { duration, dir, tilt, travel })` Params: `duration` = 0.9 (length of the transition in seconds; springs use it to keep their feel); `dir` = "left" (direction); `tilt` = 7 (tilt in degrees); `travel` = 1.35 (travel distance in widths) - A winds up, then whips out tilted and smeared; a light streak crosses at full speed; B whips in, overshoots and settles, its content trailing. - Stack A and B in one positioned slot (their parent); give the slot overflow:hidden to keep travel inside it. - Pass the real duration in seconds and call it through p = 1: that is when it hides the layers it made. - Render with --motion-blur 5. Install: `npx paper-motion add whip-pan` · https://paper-motion.vercel.app/r/whip-pan.json ```js import { whipPan } from './moves/whip-pan.js'; // A and B (two states of a card) stacked in one positioned slot; 1.1 s from 2.0 s: s.update((t) => whipPan(cardA, cardB, progress(t, 2.0, 3.1), { duration: 1.1 })); ``` ## Transitions ### Cells · `cells` B appears through a grid of squares that grow in a diagonal wave. Signature: `cells(a, b, p, { cols, rows, origin, spread, curve })` Params: `cols` = 16 (grid columns); `rows` = 9 (grid rows); `origin` = [0,0] (transform origin (CSS)); `spread` = 0.6 (how much the wave spreads (0–1)); `curve` = "ease.outCubic" (easing function (from `ease`)) - B shows through a grid of squares that grow from their centres in a wave from `origin` (0..1, 0..1). - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add cells` · https://paper-motion.vercel.app/r/cells.json ```js import { cells } from './moves/cells.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: cells(a, b, progress(t, 2.0, 2.6)); ``` ### Crossfade · `crossfade` A dissolves into B. Signature: `crossfade(a, b, p, { curve })` Params: `curve` (easing function (from `ease`)) - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add crossfade` · https://paper-motion.vercel.app/r/crossfade.json ```js import { crossfade } from './moves/crossfade.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: crossfade(a, b, progress(t, 2.0, 2.6)); ``` ### Cut · `cut` Hard cut from A to B, on the beat. Signature: `cut(a, b, p)` - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add cut` · https://paper-motion.vercel.app/r/cut.json ```js import { cut } from './moves/cut.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: cut(a, b, progress(t, 2.0, 2.6)); ``` ### Flash · `flash` An overexposed white flash hides the cut from A to B. Signature: `flash(a, b, p, { color, bloom, peak })` Params: `color` = "#fff" (color (CSS)); `bloom` = 18 (blur at the peak in px); `peak` = 0.4 (where the flash peaks (0–1)) - An overexposed white flash: A burns out, the cut happens at the peak, B comes back from the white. - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add flash` · https://paper-motion.vercel.app/r/flash.json ```js import { flash } from './moves/flash.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: flash(a, b, progress(t, 2.0, 2.6)); ``` ### Flip 3D · `flip-3d` The frame flips over like a card and shows B on the back. Signature: `flip3D(a, b, p, { depth, perspective, curve })` Params: `depth` = 0.82 (how deep the camera dives); `perspective` = 2400 (3D perspective in px); `curve` = "ease.inOutCubic" (easing function (from `ease`)) - The frame flips over like a card (around Y) and B is on the back; it pulls back mid-flip. - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add flip-3d` · https://paper-motion.vercel.app/r/flip-3d.json ```js import { flip3D } from './moves/flip-3d.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: flip3D(a, b, progress(t, 2.0, 2.6)); ``` ### Glitch · `glitch` A few frames of torn bands and RGB split, then B. Signature: `glitch(a, b, p, { seed, steps, rgb, shift })` Params: `seed` = 1 (random seed; change it for a different variation); `steps` = 22 (glitch changes per transition); `rgb` = 16 (RGB split in px); `shift` = 140 (band shift in px) - A few frames of torn bands, jitter and RGB split; the bands show more of B until B holds. - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). - Only for a digital or raw identity. Install: `npx paper-motion add glitch` · https://paper-motion.vercel.app/r/glitch.json ```js import { glitch } from './moves/glitch.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: glitch(a, b, progress(t, 2.0, 2.6)); ``` ### Iris · `iris` B opens from a circle that grows out of a point. Signature: `iris(a, b, p, { x, y, curve })` Params: `x` = "50%" (center x (CSS)); `y` = "50%" (center y (CSS)); `curve` = "ease.inOutCubic" (easing function (from `ease`)) - B opens from a circle growing out of (x, y); A sinks back a little. - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add iris` · https://paper-motion.vercel.app/r/iris.json ```js import { iris } from './moves/iris.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: iris(a, b, progress(t, 2.0, 2.6)); ``` ### Mask reveal · `mask-reveal` B is revealed from one edge, behind a hard mask line. Signature: `maskReveal(a, b, p, { from, curve })` Params: `from` = "bottom" (start value); `curve` = "ease.outExpo" (easing function (from `ease`)) - B is revealed from an edge (`from`: bottom, top, left, right) behind a hard mask. - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add mask-reveal` · https://paper-motion.vercel.app/r/mask-reveal.json ```js import { maskReveal } from './moves/mask-reveal.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: maskReveal(a, b, progress(t, 2.0, 2.6)); ``` ### Push · `push` B pushes A out of frame. Signature: `push(a, b, p, { dir, curve })` Params: `dir` = "left" (direction); `curve` = "ease.inOutQuart" (easing function (from `ease`)) - B pushes A out; `dir` is where A leaves to. - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add push` · https://paper-motion.vercel.app/r/push.json ```js import { push } from './moves/push.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: push(a, b, progress(t, 2.0, 2.6)); ``` ### Scan reveal · `scan-reveal` B draws in under a moving scan line. Signature: `scanReveal(a, b, p, { line, curve })` Params: `line` (line height (em)); `curve` = "ease.linear" (easing function (from `ease`)) - B draws in from the top under a scan line element (`line`, absolutely positioned inside B's parent). - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add scan-reveal` · https://paper-motion.vercel.app/r/scan-reveal.json ```js import { scanReveal } from './moves/scan-reveal.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: scanReveal(a, b, progress(t, 2.0, 2.6)); ``` ### Slices · `slices` B comes in as horizontal strips from alternating sides. Signature: `slices(a, b, p, { n, each, curve })` Params: `n` = 8 (number of strips); `each` = 0.05 (delay between items (s)); `curve` = "ease.outExpo" (easing function (from `ease`)) - B comes in as `n` horizontal strips, alternating left and right, staggered top to bottom. - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add slices` · https://paper-motion.vercel.app/r/slices.json ```js import { slices } from './moves/slices.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: slices(a, b, progress(t, 2.0, 2.6)); ``` ### Whip · `whip` A fast push with horizontal motion blur. Signature: `whip(a, b, p, { dir, blur, curve })` Params: `dir` = "left" (direction); `blur` = 70 (blur strength in px); `curve` = "ease.inOutQuint" (easing function (from `ease`)) - B pushes A out very fast, with horizontal motion blur that follows the speed. `dir` is where A leaves to. - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add whip` · https://paper-motion.vercel.app/r/whip.json ```js import { whip } from './moves/whip.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: whip(a, b, progress(t, 2.0, 2.6)); ``` ### Wipe · `wipe` A soft diagonal edge uncovers B. Signature: `wipe(a, b, p, { angle, soft, curve })` Params: `angle` = 100 (angle in degrees); `soft` = 30 (softness of the edge (%)); `curve` (easing function (from `ease`)) - B is uncovered by a soft edge at `angle` degrees; A stays underneath. - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add wipe` · https://paper-motion.vercel.app/r/wipe.json ```js import { wipe } from './moves/wipe.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: wipe(a, b, progress(t, 2.0, 2.6)); ``` ### Zoom through · `zoom-through` The camera dives through A and lands on B. Signature: `zoomThrough(a, b, p, { scale, origin, curve })` Params: `scale` = 6 (how far the camera dives (scale at the end)); `origin` = "50% 50%" (transform origin (CSS)); `curve` = "ease.inOutCubic" (easing function (from `ease`)) - The camera dives through A (scaling past the lens) and lands on B. `origin` is where the camera dives in (put it on the subject, e.g. '30% 50%'). B lands from slightly larger, so no edge shows. - At p = 0 only A shows, at p = 1 only B; keep B above A (z-index). Install: `npx paper-motion add zoom-through` · https://paper-motion.vercel.app/r/zoom-through.json ```js import { zoomThrough } from './moves/zoom-through.js'; // two stacked layers, B above A; in s.update(t), from 2.0 s to 2.6 s: zoomThrough(a, b, progress(t, 2.0, 2.6)); ``` ## Text effects ### Bar reveal · `bar-reveal` A solid bar sweeps across and leaves the line behind it. Signature: `barReveal(el, t, { start, duration, color, curve })` Params: `start` = 0 (start time in seconds); `duration` = 0.8 (length of the transition in seconds; springs use it to keep their feel); `color` = "#fff" (color (CSS)); `curve` = "ease.inOutQuart" (easing function (from `ease`)) - A solid bar grows over the line, then pulls away to the other side, leaving the text behind it. Install: `npx paper-motion add bar-reveal` · https://paper-motion.vercel.app/r/bar-reveal.json ```js import { barReveal } from './moves/bar-reveal.js'; s.update((t) => barReveal(el, t, { start: 0.5 })); ``` ### Blur in · `blur-in` Text comes into focus from a blur. Signature: `blurIn(el, t, { start, duration, blur, curve })` Params: `start` = 0 (start time in seconds); `duration` = 0.8 (length of the transition in seconds; springs use it to keep their feel); `blur` = 14 (blur strength in px); `curve` = "ease.outCubic" (easing function (from `ease`)) - Text comes into focus from a blur. Install: `npx paper-motion add blur-in` · https://paper-motion.vercel.app/r/blur-in.json ```js import { blurIn } from './moves/blur-in.js'; s.update((t) => blurIn(el, t, { start: 0.5 })); ``` ### Flip in · `flip-in` Letters flip up into place in 3D, one after another. Signature: `flipIn(el, t, { start, each, duration, angle, curve })` Params: `start` = 0 (start time in seconds); `each` = 0.045 (delay between items (s)); `duration` = 0.8 (length of the transition in seconds; springs use it to keep their feel); `angle` = -100 (angle in degrees); `curve` = "ease.outBack" (easing function (from `ease`)) - Letters flip up into place around their baseline, in 3D. Install: `npx paper-motion add flip-in` · https://paper-motion.vercel.app/r/flip-in.json ```js import { flipIn } from './moves/flip-in.js'; s.update((t) => flipIn(el, t, { start: 0.5 })); ``` ### Odometer · `odometer` A number counts up with rolling digit wheels, like an odometer. Signature: `odometer(el, t, { from, to, start, duration, curve, separator })` Params: `from` = 0 (start value); `to` = 1000 (end value); `start` = 0 (start time in seconds); `duration` = 2 (length of the transition in seconds; springs use it to keep their feel); `curve` = "ease.outExpo" (easing function (from `ease`)); `separator` = "," (thousands separator) - Counts from `from` to `to` on rolling digit wheels; a wheel only turns when the one to its right rolls over. Install: `npx paper-motion add odometer` · https://paper-motion.vercel.app/r/odometer.json ```js import { odometer } from './moves/odometer.js'; s.update((t) => odometer(el, t, { start: 0.5 })); ``` ### Pop in · `pop-in` Letters pop up one by one on a spring, with a little overshoot. Signature: `popIn(el, t, { start, each, stiffness, damping, rise })` Params: `start` = 0 (start time in seconds); `each` = 0.04 (delay between items (s)); `stiffness` = 260 (spring stiffness (higher is snappier)); `damping` = 13 (spring damping (lower bounces more)); `rise` = 0.45 (rise distance (em)) - Letters pop up from the baseline on a spring. Install: `npx paper-motion add pop-in` · https://paper-motion.vercel.app/r/pop-in.json ```js import { popIn } from './moves/pop-in.js'; s.update((t) => popIn(el, t, { start: 0.5 })); ``` ### Roll · `roll` The last word rolls like a slot machine through a list of words. Signature: `roll(el, list, t, { start, every, duration, curve, line })` Params: `start` = 0 (start time in seconds); `every` = 0.9 (seconds between words); `duration` = 0.55 (length of the transition in seconds; springs use it to keep their feel); `curve` = "ease.inOutQuart" (easing function (from `ease`)); `line` = 1.3 (line height (em)) - The element rolls through `list` like a slot machine, one word every `every` seconds; its width follows. Install: `npx paper-motion add roll` · https://paper-motion.vercel.app/r/roll.json ```js import { roll } from './moves/roll.js'; s.update((t) => roll(el, ['move.', 'faster.', 'yours.'], t, { start: 0.5 })); ``` ### Scramble · `scramble` Letters cycle through random glyphs and lock into place, left to right. Signature: `scramble(el, t, { start, duration, fps, rate, seed, glyphs })` Params: `start` = 0 (start time in seconds); `duration` = 1.4 (length of the transition in seconds; springs use it to keep their feel); `fps` = 30 (scene fps); `rate` = 2 (frames per glyph change); `seed` = 1 (random seed; change it for a different variation); `glyphs` = "ABCDEFGHJKLMNPQRSTUVWXYZ0123456789#%&*+=/<>" (glyphs used while scrambling) - Letters show random glyphs, then lock into the real text from left to right. Widths stay fixed. Install: `npx paper-motion add scramble` · https://paper-motion.vercel.app/r/scramble.json ```js import { scramble } from './moves/scramble.js'; s.update((t) => scramble(el, t, { start: 0.5 })); ``` ### Track in · `track-in` Letters settle from wide spacing to their tracking. Signature: `trackIn(el, t, { start, duration, from, to, curve })` Params: `start` = 0 (start time in seconds); `duration` = 1 (length of the transition in seconds; springs use it to keep their feel); `from` = 0.4 (start value); `to` = 0 (end value); `curve` = "ease.outExpo" (easing function (from `ease`)) - Letters settle from wide spacing (`from`, em) to `to`. Install: `npx paper-motion add track-in` · https://paper-motion.vercel.app/r/track-in.json ```js import { trackIn } from './moves/track-in.js'; s.update((t) => trackIn(el, t, { start: 0.5 })); ``` ### Type on · `type-on` Text types itself, terminal style, with a block cursor. Signature: `typeOn(el, text, t, { start, cps, times, cursor, blink })` Params: `start` = 0 (start time in seconds); `cps` = 35 (characters per second); `times` = null (per-character times (from typingTimes)); `cursor` = null (cursor element); `blink` = 2.2 (cursor blink rate (Hz)) - When each character of `text` appears, typed by a person: quick bursts inside words, a beat after spaces, longer after punctuation, the odd hesitation. Deterministic per seed. Use the same times for the text (typeOn's `times`) and the sound (keySounds), so every letter lands on its keystroke. @returns {number[]} times in seconds, one per character export function typingTimes(text, { start = 0, cps = 11, seed = 1 } = {}) { const r = rng(seed).next, base = 1 cps, out = []; let t = start; for (let i = 0; i < text.length; i++) { const prev = text[i - 1] ?? '', ch = text[i]; let k = 0.7 + 0.45 * r(); // inside a word: fast, uneven if (prev === ' ') k = 1.35 + 0.5 * r(); // starting a new word if (/[.,;:!?]/.test(prev)) k = 2.2 + 1.2 * r(); // after punctuation if (/[\/\-_@]/.test(ch) || /[\/\-_@]/.test(prev)) k *= 1.25; // symbols need a reach if (r() < 0.04) k *= 2.4; // a hesitation t += i === 0 ? 0 : base * k; out.push(t); } return out; } Schedules one keystroke sound per character at `times` (from typingTimes), plus an optional enter. export function keySounds(s, text, times, { bank, style, gain = 0.16, seed = 1, enter = null, pan = 0.04 } = {}) { [...text].forEach((ch, i) => s.sfx(times[i], 'key', { kind: ch === ' ' ? 'space' : 'letter', gain, seed: seed * 1000 + i, pan: ((i % 5) - 2) * pan, ...(bank ? { bank } : {}), ...(style ? { style } : {}) })); if (enter !== null) s.sfx(enter, 'key', { kind: 'enter', gain: gain * 1.1, seed: seed * 1000 + 999, ...(bank ? { bank } : {}), ...(style ? { style } : {}) }); } Types `text` from `start` at `cps` characters a second, or at explicit `times` (typingTimes); `cursor` (an element) is solid while typing, blinks at `blink` Hz after. - The file also exports typingTimes (human typing rhythm) and keySounds (one keystroke sound per letter). Install: `npx paper-motion add type-on` · https://paper-motion.vercel.app/r/type-on.json ```js import { typeOn } from './moves/type-on.js'; s.update((t) => typeOn(el, 'Your line here', t, { start: 0.5 })); ``` ### Word rise · `word-rise` Words rise one by one from behind a mask line. Signature: `wordRise(el, t, { start, each, duration, curve })` Params: `start` = 0 (start time in seconds); `each` = 0.08 (delay between items (s)); `duration` = 0.5 (length of the transition in seconds; springs use it to keep their feel); `curve` = "ease.outExpo" (easing function (from `ease`)) - Words rise one by one from behind a mask line. Install: `npx paper-motion add word-rise` · https://paper-motion.vercel.app/r/word-rise.json ```js import { wordRise } from './moves/word-rise.js'; s.update((t) => wordRise(el, t, { start: 0.5 })); ``` ## Camera and energy ### Draw on · `draw-on` Lines and shapes draw themselves stroke by stroke. Signature: `drawOn(svg, t, { start, each, duration, curve })` Params: `start` = 0 (start time in seconds); `each` = 0.12 (delay between items (s)); `duration` = 1.2 (length of the transition in seconds; springs use it to keep their feel); `curve` = "ease.inOutCubic" (easing function (from `ease`)) - Every stroke in `svg` (paths, lines, circles, rects, polylines) draws itself, one after another. Install: `npx paper-motion add draw-on` · https://paper-motion.vercel.app/r/draw-on.json ```js import { drawOn } from './moves/draw-on.js'; s.update((t) => drawOn(svg, t)); ``` ### Drift · `drift` A slow, constant push-in that keeps a still frame alive. Signature: `drift(el, t, { amount, duration, origin })` Params: `amount` = 0.04 (strength); `duration` = 10 (length of the transition in seconds; springs use it to keep their feel); `origin` = "50% 50%" (transform origin (CSS)) - A slow constant push-in over `duration` seconds (default: the whole scene). Install: `npx paper-motion add drift` · https://paper-motion.vercel.app/r/drift.json ```js import { drift } from './moves/drift.js'; s.update((t) => drift(el, t)); ``` ### Orbit · `orbit` A 3D camera moves around layers set at different depths. Signature: `orbit(world, t, { start, duration, yaw, pitch, dolly, curve })` Params: `start` = 0 (start time in seconds); `duration` = 5 (length of the transition in seconds; springs use it to keep their feel); `yaw` = [-20,20] (yaw range [from, to] in degrees); `pitch` = [8,-6] (pitch range [from, to] in degrees); `dolly` = [-200,200] (dolly range [from, to] in px); `curve` = "ease.inOutSine" (easing function (from `ease`)) - A 3D camera around a world whose children sit at different translateZ. Ranges are [from, to]. - Children of world sit at different translateZ; the stage needs a perspective. Install: `npx paper-motion add orbit` · https://paper-motion.vercel.app/r/orbit.json ```js import { orbit } from './moves/orbit.js'; s.update((t) => orbit(world, t)); ``` ### Punch · `punch` The frame punches in on each hit and springs back. Signature: `punch(el, t, { hits, amount, stiffness, damping, origin })` Params: `hits` = [0] (times (s) of the hits, e.g. on the beat); `amount` = 0.09 (strength); `stiffness` = 420 (spring stiffness (higher is snappier)); `damping` = 16 (spring damping (lower bounces more)); `origin` = "50% 50%" (transform origin (CSS)) - The frame jumps in by `amount` on each hit and springs back. - Put hits on the beat or on a sound cue, never on every beat. Install: `npx paper-motion add punch` · https://paper-motion.vercel.app/r/punch.json ```js import { punch } from './moves/punch.js'; s.update((t) => punch(world, t, { hits: [1.0, 2.0, 2.5] })); ``` ### RGB split · `rgb-split` Red and cyan fringes burst out on each hit and fade. Signature: `rgbSplit(el, t, { hits, amount, decay, base })` Params: `hits` = [0] (times (s) of the hits, e.g. on the beat); `amount` = 22 (strength); `decay` = 6 (how fast it dies out (higher is faster)); `base` = 0 (resting split in px) - Red and cyan fringes burst out on each hit and fade. - Put hits on the beat or on a sound cue, never on every beat. Install: `npx paper-motion add rgb-split` · https://paper-motion.vercel.app/r/rgb-split.json ```js import { rgbSplit } from './moves/rgb-split.js'; s.update((t) => rgbSplit(world, t, { hits: [1.0, 2.0, 2.5] })); ``` ### Shake · `shake` A camera shake on each hit that dies out fast. Signature: `shake(el, t, { hits, amount, rot, decay, freq, seed })` Params: `hits` = [0] (times (s) of the hits, e.g. on the beat); `amount` = 34 (strength); `rot` = 1.4 (rotation in degrees); `decay` = 7 (how fast it dies out (higher is faster)); `freq` = 24 (shake frequency); `seed` = 1 (random seed; change it for a different variation) - A camera shake on each time in `hits`, dying out at `decay`. - Put hits on the beat or on a sound cue, never on every beat. Install: `npx paper-motion add shake` · https://paper-motion.vercel.app/r/shake.json ```js import { shake } from './moves/shake.js'; s.update((t) => shake(world, t, { hits: [1.0, 2.0, 2.5] })); ``` ## Backgrounds ### Simplex Noise · acid · `acid-simplex` A multi-color gradient mapped into smooth, animated curves built as a combination of 2 Simplex noises, in acid. Params: `speed` = 0.5 (animation speed (0 = still)); `scale` = 0.6 (zoom of the pattern); `stepsPerColor` = 2 (Number of extra colors between base colors, 1 = N colors, 2 = 2×N, etc., needs 2+ colors); `softness` = 0 (edge softness); `colors` = ["#F7FA81","#7C9E25","#FFDE66","#53C953","#97FFD7"] (palette colors (hex)) - Paper shader `SimplexNoise` (animated). Tuned by hand in Paper. Install: `npx paper-motion add acid-simplex` · https://paper-motion.vercel.app/r/acid-simplex.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'acid-simplex'); ``` ### Color Panels · `color-panels` Pseudo-3D semi-transparent panels rotating around a central axis. Params: `colorBack` = "#000000" (background color behind the effect); `colors` = ["#8FA67A","#B07D73","#8EA3AD","#C9A65A","#7E7594","#E9E4D8"] (palette colors (hex)); `density` = 3 (Angle between every 2 panels); `length` = 1.1 (Panel length relative to total height); `fadeIn` = 1 (Transparency near central axis); `fadeOut` = 0.3 (Transparency near viewer); `gradient` = 0.3 (Color mixing within a panel, 0 = solid, 1 = gradient, needs 2+ colors); `speed` = 0.4 (animation speed (0 = still)) - Paper shader `ColorPanels` (animated). Install: `npx paper-motion add color-panels` · https://paper-motion.vercel.app/r/color-panels.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'color-panels'); ``` ### Dithering · clay warp · `dither-clay` Animated 2-color dithering over multiple pattern sources (noise, warp, dots, waves, ripple, swirl, sphere), in clay warp. Params: `speed` = 1 (animation speed (0 = still)); `shape` = "warp" (base pattern); `type` = "4x4" (variant); `size` = 2.5 (dot or pattern size); `scale` = 1 (zoom of the pattern); `colorBack` = "#00000000" (background color behind the effect); `colorFront` = "#B07D73" (foreground color); `fit` = "contain" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)) - Paper shader `Dithering` (animated). Tuned by hand in Paper. Install: `npx paper-motion add dither-clay` · https://paper-motion.vercel.app/r/dither-clay.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'dither-clay'); ``` ### Dithering · ochre sphere · `dither-ochre` Animated 2-color dithering over multiple pattern sources (noise, warp, dots, waves, ripple, swirl, sphere), in ochre sphere. Params: `speed` = 1 (animation speed (0 = still)); `shape` = "sphere" (base pattern); `type` = "4x4" (variant); `size` = 2 (dot or pattern size); `scale` = 0.7 (zoom of the pattern); `colorBack` = "#00000000" (background color behind the effect); `colorFront` = "#C9A65A" (foreground color) - Paper shader `Dithering` (animated). Tuned by hand in Paper. Install: `npx paper-motion add dither-ochre` · https://paper-motion.vercel.app/r/dither-ochre.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'dither-ochre'); ``` ### Dithering · ink on paper · `dither-paper` Animated 2-color dithering over multiple pattern sources (noise, warp, dots, waves, ripple, swirl, sphere), in ink on paper. Params: `speed` = 1 (animation speed (0 = still)); `shape` = "simplex" (base pattern); `type` = "8x8" (variant); `size` = 2 (dot or pattern size); `scale` = 0.6 (zoom of the pattern); `colorBack` = "#00000000" (background color behind the effect); `colorFront` = "#3A3833" (foreground color) - Paper shader `Dithering` (animated). Tuned by hand in Paper. Install: `npx paper-motion add dither-paper` · https://paper-motion.vercel.app/r/dither-paper.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'dither-paper'); ``` ### Dithering · sage on charcoal · `dither-sage` Animated 2-color dithering over multiple pattern sources (noise, warp, dots, waves, ripple, swirl, sphere), in sage on charcoal. Params: `speed` = 1 (animation speed (0 = still)); `shape` = "simplex" (base pattern); `type` = "4x4" (variant); `size` = 2 (dot or pattern size); `scale` = 0.6 (zoom of the pattern); `colorBack` = "#00000000" (background color behind the effect); `colorFront` = "#8FA67A" (foreground color) - Paper shader `Dithering` (animated). Tuned by hand in Paper. Install: `npx paper-motion add dither-sage` · https://paper-motion.vercel.app/r/dither-sage.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'dither-sage'); ``` ### Dithering · slate ripple · `dither-slate` Animated 2-color dithering over multiple pattern sources (noise, warp, dots, waves, ripple, swirl, sphere), in slate ripple. Params: `speed` = 1 (animation speed (0 = still)); `shape` = "ripple" (base pattern); `type` = "2x2" (variant); `size` = 3 (dot or pattern size); `scale` = 0.8 (zoom of the pattern); `colorBack` = "#00000000" (background color behind the effect); `colorFront` = "#8EA3AD" (foreground color) - Paper shader `Dithering` (animated). Tuned by hand in Paper. Install: `npx paper-motion add dither-slate` · https://paper-motion.vercel.app/r/dither-slate.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'dither-slate'); ``` ### Dithering · `dither-sphere` Animated 2-color dithering over multiple pattern sources (noise, warp, dots, waves, ripple, swirl, sphere). Params: `colorBack` = "#000000" (background color behind the effect); `colorFront` = "#A3A3A3" (foreground color); `shape` = "sphere" (base pattern); `type` = "4x4" (variant); `size` = 2 (dot or pattern size); `scale` = 0.6 (zoom of the pattern); `speed` = 1 (animation speed (0 = still)) - Paper shader `Dithering` (animated). Install: `npx paper-motion add dither-sphere` · https://paper-motion.vercel.app/r/dither-sphere.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'dither-sphere'); ``` ### Dithering · sage · `dither-warp-sage` Animated 2-color dithering over multiple pattern sources (noise, warp, dots, waves, ripple, swirl, sphere), in sage. Params: `colorBack` = "#000000" (background color behind the effect); `colorFront` = "#8FA67A" (foreground color); `shape` = "warp" (base pattern); `type` = "8x8" (variant); `size` = 3 (dot or pattern size); `scale` = 1 (zoom of the pattern); `speed` = 0.6 (animation speed (0 = still)) - Paper shader `Dithering` (animated). Install: `npx paper-motion add dither-warp-sage` · https://paper-motion.vercel.app/r/dither-warp-sage.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'dither-warp-sage'); ``` ### Dot Orbit · `dot-orbit` Animated multi-color dots pattern with each dot orbiting around its cell center. Params: `colorBack` = "#000000" (background color behind the effect); `colors` = ["#ffffff","#8EA3AD","#5F7A86","#2a2a2a"] (palette colors (hex)); `size` = 0.8 (dot or pattern size); `sizeRange` = 0.3 (Random variation in shape size, 0 = uniform, higher = random up to base size); `spreading` = 0.8 (Maximum orbit distance around cell center, dots are static at 0); `stepsPerColor` = 3 (Number of extra colors between base colors, 1 = N colors, 2 = 2×N, etc., needs 2+ colors); `speed` = 1 (animation speed (0 = still)) - Paper shader `DotOrbit` (animated). Install: `npx paper-motion add dot-orbit` · https://paper-motion.vercel.app/r/dot-orbit.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'dot-orbit'); ``` ### Fluted Glass · glass · `fluted-glass` Fluted glass image filter that transforms an image into streaked, ribbed distortions, giving a mix of clarity and obscurity, in glass. Params: `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `colorBack` = "#00000000" (background color behind the effect); `colorShadow` = "#000000" (Shadows color in RGBA, needs shadows > 0); `colorHighlight` = "#ffffff" (Highlights color in RGBA, needs highlights > 0); `shadows` = 0.25 (Color gradient added over image and background, following distortion shape, needs colorShadow alpha > 0); `size` = 0.45 (dot or pattern size); `angle` = 0 (Direction of the grid relative to the image in degrees); `distortionShape` = "prism" (Shape of distortion); `highlights` = 0.12 (Thin strokes along distortion shape, useful for antialiasing on small grid); `shape` = "lines" (base pattern); `distortion` = 0.5 (amount of organic distortion); `blur` = 0 (One-directional blur over the image and extra blur around edges); `edges` = 0.25 (Glass distortion and softness on the image edges); `grainOverlay` = 0.05 (grain laid over the image) - Paper shader `FlutedGlass` (still). - Uses an image (installed to brand/assets/materials/); swap `image` for your own picture or texture. - Breathes on `shift` from -0.15 to 0.15 so a still shader stays alive. Install: `npx paper-motion add fluted-glass` · https://paper-motion.vercel.app/r/fluted-glass.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'fluted-glass'); ``` ### Gem Smoke · `gem-smoke` Animated color fields placed over uploaded logo shape. Params: `fit` = "contain" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `scale` = 0.8 (zoom of the pattern); `shape` = "none" (base pattern); `colorBack` = "#000000" (background color behind the effect); `colorInner` = "#141414" (Additional color inside the input shape, mixing with smoke (RGBA)); `colors` = ["#8EA3AD","#E9E4D8"] (palette colors (hex)); `outerGlow` = 0.55 (Visibility of smoke shape outside the input shape); `innerGlow` = 1 (Visibility of smoke shape inside the input shape); `innerDistortion` = 0.8 (Power of smoke distortion inside the input shape, needs innerGlow > 0); `outerDistortion` = 0.6 (Power of smoke distortion outside the input shape, needs outerGlow > 0); `size` = 0.8 (dot or pattern size); `speed` = 1 (animation speed (0 = still)) - Paper shader `GemSmoke` (animated). - Needs the brand wordmark (brand/tokens.json wordmark files; `pamo wordmark` makes them). Install: `npx paper-motion add gem-smoke` · https://paper-motion.vercel.app/r/gem-smoke.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'gem-smoke'); ``` ### God Rays · `god-rays` Animated rays of light radiating from the center, blended with up to 5 colors. Params: `colorBack` = "#000000" (background color behind the effect); `colorBloom` = "#2a2a2a" (Color overlay blended with the rays in RGBA, needs bloom > 0); `colors` = ["#ffffff40","#C9A65A80","#ffffff","#8EA3AD"] (palette colors (hex)); `density` = 0.3 (The number of rays); `spotty` = 0.3 (The length of the rays, higher = more spots/shorter rays); `midIntensity` = 0.4 (Brightness/intensity of the central glow, needs midSize > 0); `midSize` = 0.2 (Size of the circular glow shape in the center, needs midIntensity > 0); `intensity` = 0.7 (intensity); `bloom` = 0.35 (Strength of the bloom/overlay effect, 0 = alpha blend, 1 = additive blend); `speed` = 0.5 (animation speed (0 = still)) - Paper shader `GodRays` (animated). Install: `npx paper-motion add god-rays` · https://paper-motion.vercel.app/r/god-rays.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'god-rays'); ``` ### Grain Gradient · clay · `grain-clay` Multi-color gradients with grainy, noise-textured distortion available in 7 animated abstract forms, in clay. Params: `colorBack` = "#000000" (background color behind the effect); `colors` = ["#3F2925","#B07D73","#EADBC8"] (palette colors (hex)); `shape` = "wave" (base pattern); `softness` = 0.8 (edge softness); `intensity` = 0.25 (intensity); `noise` = 0.3 (Grainy noise overlay); `speed` = 0.4 (animation speed (0 = still)) - Paper shader `GrainGradient` (animated). Install: `npx paper-motion add grain-clay` · https://paper-motion.vercel.app/r/grain-clay.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'grain-clay'); ``` ### Grain Gradient · slate · `grain-slate` Multi-color gradients with grainy, noise-textured distortion available in 7 animated abstract forms, in slate. Params: `colorBack` = "#000000" (background color behind the effect); `colors` = ["#5F7A86","#8EA3AD","#E6E6E6"] (palette colors (hex)); `shape` = "blob" (base pattern); `softness` = 0.6 (edge softness); `intensity` = 0.35 (intensity); `noise` = 0.35 (Grainy noise overlay); `speed` = 0.6 (animation speed (0 = still)) - Paper shader `GrainGradient` (animated). Install: `npx paper-motion add grain-slate` · https://paper-motion.vercel.app/r/grain-slate.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'grain-slate'); ``` ### Dithering · gray · `gray-dither` Animated 2-color dithering over multiple pattern sources (noise, warp, dots, waves, ripple, swirl, sphere), in gray. Params: `speed` = 1 (animation speed (0 = still)); `shape` = "simplex" (base pattern); `type` = "4x4" (variant); `size` = 2 (dot or pattern size); `scale` = 0.6 (zoom of the pattern); `colorBack` = "#00000000" (background color behind the effect); `colorFront` = "#393939" (foreground color) - Paper shader `Dithering` (animated). Tuned by hand in Paper. Install: `npx paper-motion add gray-dither` · https://paper-motion.vercel.app/r/gray-dither.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'gray-dither'); ``` ### Radial Gradient · green · `green-radial` Radial gradient with up to 10 blended colors, featuring advanced mixing modes, focal point controls, shape distortion, and grain effects, in green. Params: `scale` = 1 (zoom of the pattern); `offsetX` = 0 (horizontal offset); `offsetY` = 0.06 (vertical offset); `radius` = 1.09 (radius); `focalDistance` = 0.74 (Distance of the focal point from center); `focalAngle` = 0 (Angle of the focal point in degrees, needs focalDistance > 0); `falloff` = 0.33 (Gradient decay, 0 = equal color distribution); `mixing` = 0.64 (Blending behavior, 0 = hard stripes, 1 = smooth gradient); `distortionShift` = 0 (Radial distortion offset, needs distortion > 0); `distortionFreq` = 12 (Radial distortion frequency, needs distortion > 0); `colors` = ["#5DC27E","#C8EE6C","#FFFFFF"] (palette colors (hex)); `colorBack` = "#00000000" (background color behind the effect) - Paper shader `StaticRadialGradient` (still). Tuned by hand in Paper. Install: `npx paper-motion add green-radial` · https://paper-motion.vercel.app/r/green-radial.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'green-radial'); ``` ### Halftone Dots · clay on sand · `halftone-clay` A halftone-dot image filter featuring customizable grids, color palettes, and dot styles, in clay on sand. Params: `contrast` = 0.5 (contrast); `originalColors` = false (Use sampled image's original colors instead of colorFront); `inverted` = false (Inverts the image luminance, doesn't affect the color scheme, needs contrast > 0); `grid` = "hex" (Grid type (0 = square, 1 = hex)); `radius` = 1.25 (radius); `size` = 0.5 (dot or pattern size); `scale` = 1 (zoom of the pattern); `grainMixer` = 0.2 (grain mixed into the colors); `grainOverlay` = 0.2 (grain laid over the image); `grainSize` = 0.5 (grain size); `type` = "classic" (variant); `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `colorFront` = "#8A4F3D" (foreground color); `colorBack` = "#00000000" (background color behind the effect) - Paper shader `HalftoneDots` (still). Tuned by hand in Paper. - Its image is a remote URL; swap `image` for your own picture. Install: `npx paper-motion add halftone-clay` · https://paper-motion.vercel.app/r/halftone-clay.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'halftone-clay'); ``` ### Halftone Cmyk · `halftone-cmyk` CMYK halftone printing effect applied to images with customizable dot patterns and ink colors for each channel (Cyan, Magenta, Yellow, Black). Params: `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `colorBack` = "#E9E4D8" (background color behind the effect); `colorC` = "#8EA3AD" (Cyan ink color in RGBA); `colorM` = "#B07D73" (Magenta ink color in RGBA); `colorY` = "#C9A65A" (Yellow ink color in RGBA); `colorK` = "#141414" (Black ink color in RGBA); `size` = 0.2 (dot or pattern size); `contrast` = 1 (contrast); `softness` = 1 (edge softness); `grainSize` = 0.5 (grain size); `gridNoise` = 0.2 (Strength of smooth noise applied to both dot positions and color sampling, positions only with sharp type); `type` = "ink" (variant) - Paper shader `HalftoneCmyk` (still). - Uses an image (installed to brand/assets/materials/); swap `image` for your own picture or texture. - Breathes on `size` from 0.16 to 0.26 so a still shader stays alive. Install: `npx paper-motion add halftone-cmyk` · https://paper-motion.vercel.app/r/halftone-cmyk.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'halftone-cmyk'); ``` ### Halftone Dots · `halftone-dots` A halftone-dot image filter featuring customizable grids, color palettes, and dot styles. Params: `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `colorBack` = "#000000" (background color behind the effect); `colorFront` = "#E9E4D8" (foreground color); `size` = 0.5 (dot or pattern size); `radius` = 1.25 (radius); `contrast` = 0.45 (contrast); `originalColors` = false (Use sampled image's original colors instead of colorFront); `inverted` = true (Inverts the image luminance, doesn't affect the color scheme, needs contrast > 0); `grainMixer` = 0.15 (grain mixed into the colors); `grainOverlay` = 0.1 (grain laid over the image); `grid` = "hex" (Grid type (0 = square, 1 = hex)); `type` = "gooey" (variant) - Paper shader `HalftoneDots` (still). - Uses an image (installed to brand/assets/materials/); swap `image` for your own picture or texture. - Breathes on `size` from 0.35 to 0.6 so a still shader stays alive. Install: `npx paper-motion add halftone-dots` · https://paper-motion.vercel.app/r/halftone-dots.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'halftone-dots'); ``` ### Halftone Dots · `halftone-hex` A halftone-dot image filter featuring customizable grids, color palettes, and dot styles. Params: `contrast` = 0.4 (contrast); `originalColors` = false (Use sampled image's original colors instead of colorFront); `inverted` = false (Inverts the image luminance, doesn't affect the color scheme, needs contrast > 0); `grid` = "hex" (Grid type (0 = square, 1 = hex)); `radius` = 1.25 (radius); `size` = 0.5 (dot or pattern size); `scale` = 1 (zoom of the pattern); `grainMixer` = 0.2 (grain mixed into the colors); `grainOverlay` = 0.2 (grain laid over the image); `grainSize` = 0.5 (grain size); `type` = "gooey" (variant); `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `colorFront` = "#2B2B2B" (foreground color); `colorBack` = "#00000000" (background color behind the effect) - Paper shader `HalftoneDots` (still). Tuned by hand in Paper. - Its image is a remote URL; swap `image` for your own picture. Install: `npx paper-motion add halftone-hex` · https://paper-motion.vercel.app/r/halftone-hex.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'halftone-hex'); ``` ### Halftone Dots · navy ink on bone · `halftone-navy` A halftone-dot image filter featuring customizable grids, color palettes, and dot styles, in navy ink on bone. Params: `contrast` = 0.4 (contrast); `originalColors` = false (Use sampled image's original colors instead of colorFront); `inverted` = false (Inverts the image luminance, doesn't affect the color scheme, needs contrast > 0); `grid` = "hex" (Grid type (0 = square, 1 = hex)); `radius` = 1.25 (radius); `size` = 0.5 (dot or pattern size); `scale` = 1 (zoom of the pattern); `grainMixer` = 0.2 (grain mixed into the colors); `grainOverlay` = 0.2 (grain laid over the image); `grainSize` = 0.5 (grain size); `type` = "gooey" (variant); `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `colorFront` = "#2F3A4A" (foreground color); `colorBack` = "#00000000" (background color behind the effect) - Paper shader `HalftoneDots` (still). Tuned by hand in Paper. - Its image is a remote URL; swap `image` for your own picture. Install: `npx paper-motion add halftone-navy` · https://paper-motion.vercel.app/r/halftone-navy.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'halftone-navy'); ``` ### Halftone Dots · bone on charcoal · `halftone-night` A halftone-dot image filter featuring customizable grids, color palettes, and dot styles, in bone on charcoal. Params: `contrast` = 0.4 (contrast); `originalColors` = false (Use sampled image's original colors instead of colorFront); `inverted` = false (Inverts the image luminance, doesn't affect the color scheme, needs contrast > 0); `grid` = "hex" (Grid type (0 = square, 1 = hex)); `radius` = 1.25 (radius); `size` = 0.5 (dot or pattern size); `scale` = 1 (zoom of the pattern); `grainMixer` = 0.2 (grain mixed into the colors); `grainOverlay` = 0.2 (grain laid over the image); `grainSize` = 0.5 (grain size); `type` = "gooey" (variant); `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `colorFront` = "#D8D0B8" (foreground color); `colorBack` = "#00000000" (background color behind the effect) - Paper shader `HalftoneDots` (still). Tuned by hand in Paper. - Its image is a remote URL; swap `image` for your own picture. Install: `npx paper-motion add halftone-night` · https://paper-motion.vercel.app/r/halftone-night.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'halftone-night'); ``` ### Halftone Dots · ochre holes · `halftone-ochre` A halftone-dot image filter featuring customizable grids, color palettes, and dot styles, in ochre holes. Params: `contrast` = 0.6 (contrast); `originalColors` = false (Use sampled image's original colors instead of colorFront); `inverted` = false (Inverts the image luminance, doesn't affect the color scheme, needs contrast > 0); `grid` = "square" (Grid type (0 = square, 1 = hex)); `radius` = 1.1 (radius); `size` = 0.6 (dot or pattern size); `scale` = 1 (zoom of the pattern); `grainMixer` = 0.2 (grain mixed into the colors); `grainOverlay` = 0.2 (grain laid over the image); `grainSize` = 0.5 (grain size); `type` = "holes" (variant); `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `colorFront` = "#7A5A24" (foreground color); `colorBack` = "#00000000" (background color behind the effect) - Paper shader `HalftoneDots` (still). Tuned by hand in Paper. - Its image is a remote URL; swap `image` for your own picture. Install: `npx paper-motion add halftone-ochre` · https://paper-motion.vercel.app/r/halftone-ochre.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'halftone-ochre'); ``` ### Halftone Dots · sage, soft squares · `halftone-sage` A halftone-dot image filter featuring customizable grids, color palettes, and dot styles, in sage, soft squares. Params: `contrast` = 0.45 (contrast); `originalColors` = false (Use sampled image's original colors instead of colorFront); `inverted` = false (Inverts the image luminance, doesn't affect the color scheme, needs contrast > 0); `grid` = "square" (Grid type (0 = square, 1 = hex)); `radius` = 1.25 (radius); `size` = 0.6 (dot or pattern size); `scale` = 1 (zoom of the pattern); `grainMixer` = 0.2 (grain mixed into the colors); `grainOverlay` = 0.2 (grain laid over the image); `grainSize` = 0.5 (grain size); `type` = "soft" (variant); `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `colorFront` = "#4E5E45" (foreground color); `colorBack` = "#00000000" (background color behind the effect) - Paper shader `HalftoneDots` (still). Tuned by hand in Paper. - Its image is a remote URL; swap `image` for your own picture. Install: `npx paper-motion add halftone-sage` · https://paper-motion.vercel.app/r/halftone-sage.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'halftone-sage'); ``` ### Heatmap · `heatmap` A glowing gradient of colors flowing through an input shape. Params: `fit` = "contain" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `scale` = 0.8 (zoom of the pattern); `colorBack` = "#000000" (background color behind the effect); `colors` = ["#3E4E57","#6F8794","#A9B8BE","#E9E4D8","#C9A65A","#B07D73","#ffffff"] (palette colors (hex)); `contour` = 0.5 (Heat intensity near the edges of the input shape); `angle` = 0 (Direction of the heatwaves in degrees, needs innerGlow or outerGlow > 0); `noise` = 0.1 (Grain applied across the entire graphic); `innerGlow` = 0.5 (Size of the heated area inside the input shape); `outerGlow` = 0.5 (Size of the heated area outside the input shape); `speed` = 0.8 (animation speed (0 = still)) - Paper shader `Heatmap` (animated). - Needs the brand wordmark (brand/tokens.json wordmark files; `pamo wordmark` makes them). Install: `npx paper-motion add heatmap` · https://paper-motion.vercel.app/r/heatmap.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'heatmap'); ``` ### Image Dithering · `image-dither` A dithering image filter with support for 4 dithering modes and multiple color palettes (2-color, 3-color, and multicolor options, using either predefined colors or colors sampled from the original im Params: `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `colorFront` = "#E9E4D8" (foreground color); `colorBack` = "#000000" (background color behind the effect); `colorHighlight` = "#ffffff" (Secondary foreground color in RGBA (set same as colorFront for classic 2-color dithering), needs originalColors off); `type` = "8x8" (variant); `size` = 2 (dot or pattern size); `colorSteps` = 2 (Number of colors to use, applies to both color modes); `originalColors` = false (Use the original colors of the image instead of the color palette); `inverted` = false (Inverts the image luminance, doesn't affect the color scheme) - Paper shader `ImageDithering` (still). - Uses an image (installed to brand/assets/materials/); swap `image` for your own picture or texture. - Breathes on `size` from 2 to 4 so a still shader stays alive. Install: `npx paper-motion add image-dither` · https://paper-motion.vercel.app/r/image-dither.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'image-dither'); ``` ### Lens Distortion · `lens-distortion` Lens Distortion image filter separates an image into shifting color layers (recreating the chromatic aberration of a lens) and warps the image geometry, curving it outward or inward like barrel and pi Params: `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `spread` = 0.6 (Strength of the color split; how far the color layers are pushed apart; 0 is off); `bias` = 1 (Shifts the colors toward one end of the spread; 0 spaces them evenly, needs spread > 0, count > 2); `angle` = 0 (Direction of the spread in degrees, needs spread > 0, perspective < 1); `perspective` = 0.1 (Shapes the spread direction from a straight line (0) to a radial burst out from the centre (1), needs spread > 0); `count` = 35 (Number of sampled color layers along the spread; higher is smoother and costlier, needs spread > 0); `dispersion` = 1 (Overall amount of color dispersion; 1 gives each layer its own color from the spectrum, 0 keeps the original image color, needs spread > 0); `dispersionColor` = 0.6 (Rotates the colors around the hue wheel, 0 to 1 for a full turn, needs spread > 0, dispersion > 0); `focusCenter` = 0.8 (Reduces the spread in a circular zone at the centre; 0 keeps it full to the centre, needs spread > 0); `focusEdges` = 1 (Reduces the spread toward the edges; 0 keeps it full to the edges, 1 restores the original image there, needs spread > 0); `swirl` = 0.35 (amount of swirl) - Paper shader `LensDistortion` (still). - Uses an image (installed to brand/assets/materials/); swap `image` for your own picture or texture. - Breathes on `swirl` from 0.1 to 0.6 so a still shader stays alive. Install: `npx paper-motion add lens-distortion` · https://paper-motion.vercel.app/r/lens-distortion.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'lens-distortion'); ``` ### Liquid Metal · `liquid-metal` Futuristic liquid metal material applied to uploaded logo or abstract shape. Params: `fit` = "contain" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `scale` = 0.8 (zoom of the pattern); `shape` = "none" (base pattern); `colorBack` = "#000000" (background color behind the effect); `colorTint` = "#ffffff" (Overlay color in RGBA (color burn blending used)); `softness` = 0.12 (edge softness); `repetition` = 5 (Density of pattern stripes); `shiftRed` = 0.3 (R-channel dispersion); `shiftBlue` = 0.3 (B-channel dispersion); `distortion` = 0.14 (amount of organic distortion); `contour` = 0.6 (Strength of the distortion on the shape edges); `angle` = 20 (Direction of pattern animation in degrees); `speed` = 1 (animation speed (0 = still)) - Paper shader `LiquidMetal` (animated). - Needs the brand wordmark (brand/tokens.json wordmark files; `pamo wordmark` makes them). Install: `npx paper-motion add liquid-metal` · https://paper-motion.vercel.app/r/liquid-metal.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'liquid-metal'); ``` ### Mesh Gradient · graphite · `mesh-graphite` A flowing composition of color spots, moving along distinct trajectories and transformed by organic distortion, in graphite. Params: `colors` = ["#050505","#3a3a3a","#cfcfcf","#121212"] (palette colors (hex)); `distortion` = 0.85 (amount of organic distortion); `swirl` = 0.35 (amount of swirl); `speed` = 0.45 (animation speed (0 = still)); `grainMixer` = 0.12 (grain mixed into the colors); `grainOverlay` = 0.08 (grain laid over the image) - Paper shader `MeshGradient` (animated). Install: `npx paper-motion add mesh-graphite` · https://paper-motion.vercel.app/r/mesh-graphite.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'mesh-graphite'); ``` ### Mesh Gradient · sage · `mesh-sage` A flowing composition of color spots, moving along distinct trajectories and transformed by organic distortion, in sage. Params: `colors` = ["#070806","#5E7457","#C8D5A8","#1c2219"] (palette colors (hex)); `distortion` = 0.8 (amount of organic distortion); `swirl` = 0.25 (amount of swirl); `speed` = 0.4 (animation speed (0 = still)); `grainMixer` = 0.12 (grain mixed into the colors); `grainOverlay` = 0.08 (grain laid over the image) - Paper shader `MeshGradient` (animated). Install: `npx paper-motion add mesh-sage` · https://paper-motion.vercel.app/r/mesh-sage.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'mesh-sage'); ``` ### Metaballs · muted · `metaballs-muted` Up to 20 colored gooey balls moving around the center and merging into smooth organic shapes, in muted. Params: `colorBack` = "#000000" (background color behind the effect); `colors` = ["#E9E4D8","#8FA67A","#B07D73","#C9A65A","#8EA3AD"] (palette colors (hex)); `count` = 8 (Number of balls, fractional values shrink the last ball); `size` = 0.7 (dot or pattern size); `speed` = 0.6 (animation speed (0 = still)) - Paper shader `Metaballs` (animated). Install: `npx paper-motion add metaballs-muted` · https://paper-motion.vercel.app/r/metaballs-muted.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'metaballs-muted'); ``` ### Neuro Noise · slate · `neuro-slate` A glowing, web-like structure of fluid lines and soft intersections, in slate. Params: `colorFront` = "#ffffff" (foreground color); `colorMid` = "#6F8794" (Graphics main color in RGBA); `colorBack` = "#000000" (background color behind the effect); `brightness` = 0.04 (Luminosity of the crossing points); `contrast` = 0.32 (contrast); `speed` = 0.5 (animation speed (0 = still)) - Paper shader `NeuroNoise` (animated). Install: `npx paper-motion add neuro-slate` · https://paper-motion.vercel.app/r/neuro-slate.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'neuro-slate'); ``` ### Perlin Noise · sage · `perlin-sage` Classic animated 3D Perlin noise with exposed controls, in sage. Params: `colorBack` = "#000000" (background color behind the effect); `colorFront` = "#C8D5A8" (foreground color); `proportion` = 0.42 (Blend point between two colors, 0.5 = equal distribution); `softness` = 0.35 (edge softness); `octaveCount` = 2 (Perlin noise octaves number, more octaves for more detailed patterns); `persistence` = 0.6 (Roughness, falloff between octaves, needs octaveCount > 1); `lacunarity` = 2 (Frequency step, defines how compressed the pattern is, needs octaveCount > 1); `scale` = 2.5 (zoom of the pattern); `speed` = 0.3 (animation speed (0 = still)) - Paper shader `PerlinNoise` (animated). Install: `npx paper-motion add perlin-sage` · https://paper-motion.vercel.app/r/perlin-sage.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'perlin-sage'); ``` ### Pulsing Border · `pulsing-border` Luminous trails of color merging into a glowing gradient contour. Params: `colorBack` = "#000000" (background color behind the effect); `colors` = ["#E9E4D8","#8FA67A","#8EA3AD"] (palette colors (hex)); `roundness` = 0.08 (Border radius); `thickness` = 0.04 (Border base width); `margin` = 0.08; `softness` = 0.75 (edge softness); `intensity` = 0.2 (intensity); `bloom` = 0.25 (Power of glow, 0 = normal blending, 1 = additive blending); `spots` = 4 (Number of spots added for each color); `spotSize` = 0.5 (Angular size of spots); `pulse` = 0.25 (Optional pulsing animation intensity); `smoke` = 0.3 (Optional noisy shape extending the border); `smokeSize` = 0.6 (Size of the smoke effect, needs smoke > 0); `speed` = 0.8 (animation speed (0 = still)) - Paper shader `PulsingBorder` (animated). Install: `npx paper-motion add pulsing-border` · https://paper-motion.vercel.app/r/pulsing-border.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'pulsing-border'); ``` ### Radial Gradient · lavender ash · `radial-ash` Radial gradient with up to 10 blended colors, featuring advanced mixing modes, focal point controls, shape distortion, and grain effects, in lavender ash. Params: `scale` = 1 (zoom of the pattern); `offsetX` = 0 (horizontal offset); `offsetY` = 0.06 (vertical offset); `radius` = 1.09 (radius); `focalDistance` = 0.74 (Distance of the focal point from center); `falloff` = 0.33 (Gradient decay, 0 = equal color distribution); `mixing` = 0.64 (Blending behavior, 0 = hard stripes, 1 = smooth gradient); `distortionShift` = 0 (Radial distortion offset, needs distortion > 0); `distortionFreq` = 12 (Radial distortion frequency, needs distortion > 0); `colorBack` = "#00000000" (background color behind the effect); `focalAngle` = 35 (Angle of the focal point in degrees, needs focalDistance > 0); `colors` = ["#7E7594","#BDB4CB","#FFFFFF"] (palette colors (hex)) - Paper shader `StaticRadialGradient` (still). Tuned by hand in Paper. Install: `npx paper-motion add radial-ash` · https://paper-motion.vercel.app/r/radial-ash.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'radial-ash'); ``` ### Radial Gradient · moss at night · `radial-moss-night` Radial gradient with up to 10 blended colors, featuring advanced mixing modes, focal point controls, shape distortion, and grain effects, in moss at night. Params: `scale` = 1 (zoom of the pattern); `offsetX` = 0 (horizontal offset); `offsetY` = 0.06 (vertical offset); `radius` = 1.09 (radius); `focalDistance` = 0.74 (Distance of the focal point from center); `falloff` = 0.33 (Gradient decay, 0 = equal color distribution); `mixing` = 0.64 (Blending behavior, 0 = hard stripes, 1 = smooth gradient); `distortionShift` = 0 (Radial distortion offset, needs distortion > 0); `distortionFreq` = 12 (Radial distortion frequency, needs distortion > 0); `colorBack` = "#00000000" (background color behind the effect); `focalAngle` = 0 (Angle of the focal point in degrees, needs focalDistance > 0); `colors` = ["#5E7457","#A9B98A","#E9EDCF"] (palette colors (hex)); `grainMixer` = 0.3 (grain mixed into the colors); `grainOverlay` = 0.2 (grain laid over the image) - Paper shader `StaticRadialGradient` (still). Tuned by hand in Paper. Install: `npx paper-motion add radial-moss-night` · https://paper-motion.vercel.app/r/radial-moss-night.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'radial-moss-night'); ``` ### Radial Gradient · ochre sun · `radial-ochre` Radial gradient with up to 10 blended colors, featuring advanced mixing modes, focal point controls, shape distortion, and grain effects, in ochre sun. Params: `scale` = 1 (zoom of the pattern); `offsetX` = 0 (horizontal offset); `offsetY` = 0.06 (vertical offset); `radius` = 1.09 (radius); `focalDistance` = 0.74 (Distance of the focal point from center); `falloff` = 0.33 (Gradient decay, 0 = equal color distribution); `mixing` = 0.64 (Blending behavior, 0 = hard stripes, 1 = smooth gradient); `distortionShift` = 0 (Radial distortion offset, needs distortion > 0); `distortionFreq` = 12 (Radial distortion frequency, needs distortion > 0); `colorBack` = "#00000000" (background color behind the effect); `focalAngle` = -15 (Angle of the focal point in degrees, needs focalDistance > 0); `colors` = ["#B6893F","#E2C77A","#FFFBEA"] (palette colors (hex)) - Paper shader `StaticRadialGradient` (still). Tuned by hand in Paper. Install: `npx paper-motion add radial-ochre` · https://paper-motion.vercel.app/r/radial-ochre.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'radial-ochre'); ``` ### Radial Gradient · dusty rose · `radial-rose` Radial gradient with up to 10 blended colors, featuring advanced mixing modes, focal point controls, shape distortion, and grain effects, in dusty rose. Params: `scale` = 1 (zoom of the pattern); `offsetX` = 0 (horizontal offset); `offsetY` = 0.06 (vertical offset); `radius` = 1.09 (radius); `focalDistance` = 0.74 (Distance of the focal point from center); `falloff` = 0.33 (Gradient decay, 0 = equal color distribution); `mixing` = 0.64 (Blending behavior, 0 = hard stripes, 1 = smooth gradient); `distortionShift` = 0 (Radial distortion offset, needs distortion > 0); `distortionFreq` = 12 (Radial distortion frequency, needs distortion > 0); `colorBack` = "#00000000" (background color behind the effect); `focalAngle` = 0 (Angle of the focal point in degrees, needs focalDistance > 0); `colors` = ["#B07D73","#D9B3A5","#FFF6F0"] (palette colors (hex)) - Paper shader `StaticRadialGradient` (still). Tuned by hand in Paper. Install: `npx paper-motion add radial-rose` · https://paper-motion.vercel.app/r/radial-rose.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'radial-rose'); ``` ### Radial Gradient · slate · `radial-slate` Radial gradient with up to 10 blended colors, featuring advanced mixing modes, focal point controls, shape distortion, and grain effects, in slate. Params: `scale` = 1 (zoom of the pattern); `offsetX` = 0 (horizontal offset); `offsetY` = 0.06 (vertical offset); `radius` = 1.09 (radius); `focalDistance` = 0.74 (Distance of the focal point from center); `falloff` = 0.33 (Gradient decay, 0 = equal color distribution); `mixing` = 0.64 (Blending behavior, 0 = hard stripes, 1 = smooth gradient); `distortionShift` = 0 (Radial distortion offset, needs distortion > 0); `distortionFreq` = 12 (Radial distortion frequency, needs distortion > 0); `colorBack` = "#00000000" (background color behind the effect); `focalAngle` = 20 (Angle of the focal point in degrees, needs focalDistance > 0); `colors` = ["#5F7A86","#A9BDC3","#FFFFFF"] (palette colors (hex)) - Paper shader `StaticRadialGradient` (still). Tuned by hand in Paper. Install: `npx paper-motion add radial-slate` · https://paper-motion.vercel.app/r/radial-slate.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'radial-slate'); ``` ### Simplex Noise · clay desert · `simplex-clay` A multi-color gradient mapped into smooth, animated curves built as a combination of 2 Simplex noises, in clay desert. Params: `speed` = 0.5 (animation speed (0 = still)); `scale` = 0.6 (zoom of the pattern); `stepsPerColor` = 2 (Number of extra colors between base colors, 1 = N colors, 2 = 2×N, etc., needs 2+ colors); `softness` = 0 (edge softness); `colors` = ["#EADBC8","#D3A79A","#B07D73","#7A4E45","#3F2925"] (palette colors (hex)) - Paper shader `SimplexNoise` (animated). Tuned by hand in Paper. Install: `npx paper-motion add simplex-clay` · https://paper-motion.vercel.app/r/simplex-clay.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'simplex-clay'); ``` ### Simplex Noise · ochre field · `simplex-ochre` A multi-color gradient mapped into smooth, animated curves built as a combination of 2 Simplex noises, in ochre field. Params: `speed` = 0.5 (animation speed (0 = still)); `scale` = 0.6 (zoom of the pattern); `stepsPerColor` = 2 (Number of extra colors between base colors, 1 = N colors, 2 = 2×N, etc., needs 2+ colors); `softness` = 0 (edge softness); `colors` = ["#F1E8C9","#D8BC6E","#B08A3E","#6F7A3A","#3A3424"] (palette colors (hex)) - Paper shader `SimplexNoise` (animated). Tuned by hand in Paper. Install: `npx paper-motion add simplex-ochre` · https://paper-motion.vercel.app/r/simplex-ochre.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'simplex-ochre'); ``` ### Simplex Noise · sage stack · `simplex-sage` A multi-color gradient mapped into smooth, animated curves built as a combination of 2 Simplex noises, in sage stack. Params: `speed` = 0.5 (animation speed (0 = still)); `scale` = 0.6 (zoom of the pattern); `stepsPerColor` = 2 (Number of extra colors between base colors, 1 = N colors, 2 = 2×N, etc., needs 2+ colors); `softness` = 0 (edge softness); `colors` = ["#E4E4BD","#C8D5A8","#8FA67A","#5E7457","#2F3A2C"] (palette colors (hex)) - Paper shader `SimplexNoise` (animated). Tuned by hand in Paper. Install: `npx paper-motion add simplex-sage` · https://paper-motion.vercel.app/r/simplex-sage.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'simplex-sage'); ``` ### Simplex Noise · slate · `simplex-slate` A multi-color gradient mapped into smooth, animated curves built as a combination of 2 Simplex noises, in slate. Params: `colors` = ["#DCE3E3","#A9B8BE","#6F8794","#3E4E57","#1E272C"] (palette colors (hex)); `stepsPerColor` = 2 (Number of extra colors between base colors, 1 = N colors, 2 = 2×N, etc., needs 2+ colors); `softness` = 0.15 (edge softness); `speed` = 0.35 (animation speed (0 = still)) - Paper shader `SimplexNoise` (animated). Install: `npx paper-motion add simplex-slate` · https://paper-motion.vercel.app/r/simplex-slate.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'simplex-slate'); ``` ### Simplex Noise · slate sea · `simplex-slate-sea` A multi-color gradient mapped into smooth, animated curves built as a combination of 2 Simplex noises, in slate sea. Params: `speed` = 0.5 (animation speed (0 = still)); `scale` = 0.6 (zoom of the pattern); `stepsPerColor` = 2 (Number of extra colors between base colors, 1 = N colors, 2 = 2×N, etc., needs 2+ colors); `softness` = 0 (edge softness); `colors` = ["#DCE3E3","#A9B8BE","#6F8794","#3E4E57","#1E272C"] (palette colors (hex)) - Paper shader `SimplexNoise` (animated). Tuned by hand in Paper. Install: `npx paper-motion add simplex-slate-sea` · https://paper-motion.vercel.app/r/simplex-slate-sea.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'simplex-slate-sea'); ``` ### Smoke Ring · `smoke-ring` Radial multi-colored gradient shaped with layered noise for a natural, smoky aesthetic. Params: `colorBack` = "#000000" (background color behind the effect); `colors` = ["#ffffff"] (palette colors (hex)); `noiseScale` = 3 (Noise frequency); `noiseIterations` = 8 (Number of noise layers, more layers gives more details); `radius` = 0.28 (radius); `thickness` = 0.6 (Thickness of the ring shape); `innerShape` = 0.7 (Ring inner fill amount, needs radius > 0); `speed` = 0.5 (animation speed (0 = still)) - Paper shader `SmokeRing` (animated). Install: `npx paper-motion add smoke-ring` · https://paper-motion.vercel.app/r/smoke-ring.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'smoke-ring'); ``` ### Spiral · paper · `spiral-paper` A single-colored animated spiral that morphs across a wide range of shapes - from crisp, thin-lined geometry to flowing whirlpool forms and wavy, abstract rings, in paper. Params: `colorBack` = "#E9E4D8" (background color behind the effect); `colorFront` = "#000000" (foreground color); `scale` = 6 (zoom of the pattern); `density` = 2.2 (Spacing falloff simulating perspective, 0 = flat spiral); `distortion` = 0.1 (amount of organic distortion); `strokeWidth` = 0.45 (Thickness of spiral curve); `strokeTaper` = 0.5 (How much stroke loses width away from center, 0 = full visibility); `strokeCap` = 0 (Extra stroke width at the center, needs strokeWidth ≠ 0.5); `noise` = 0.25 (Noise distortion applied over the canvas, needs noiseFrequency > 0); `noiseFrequency` = 0.4 (Noise frequency, needs noise > 0); `softness` = 0.05 (edge softness); `speed` = 0.6 (animation speed (0 = still)) - Paper shader `Spiral` (animated). Install: `npx paper-motion add spiral-paper` · https://paper-motion.vercel.app/r/spiral-paper.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'spiral-paper'); ``` ### Swirl · paper · `swirl-paper` Animated bands of color twisting and bending, producing spirals, arcs, and flowing circular patterns, in paper. Params: `colorBack` = "#000000" (background color behind the effect); `colors` = ["#E9E4D8","#8a8a8a","#1a1a1a"] (palette colors (hex)); `bandCount` = 5 (Number of color bands, 0 = concentric ripples); `twist` = 0.25 (Vortex power, 0 = straight sectoral shapes); `center` = 0.2 (How far from the center the swirl colors begin to appear, needs twist > 0); `proportion` = 0.5 (Blend point between colors, 0.5 = equal distribution); `softness` = 0.1 (edge softness); `noiseFrequency` = 0.4 (Noise frequency, needs noise > 0); `noise` = 0.2 (Strength of noise distortion, needs noiseFrequency > 0); `speed` = 0.3 (animation speed (0 = still)) - Paper shader `Swirl` (animated). Install: `npx paper-motion add swirl-paper` · https://paper-motion.vercel.app/r/swirl-paper.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'swirl-paper'); ``` ### Voronoi · glass · `voronoi-glass` Anti-aliased animated Voronoi pattern with smooth and customizable edges, in glass. Params: `colors` = ["#1c1c1c","#4a4a4a"] (palette colors (hex)); `stepsPerColor` = 2 (Number of extra colors between base colors, 1 = N colors, 2 = 2×N, etc., needs 2+ colors); `colorGlow` = "#ffffff" (Color tint for radial inner shadow inside cells in RGBA, needs glow > 0); `colorGap` = "#000000" (Color used for cell borders/gaps in RGBA); `distortion` = 0.4 (amount of organic distortion); `gap` = 0.03 (Width of the border/gap between cells); `glow` = 0.45 (Strength of the radial inner shadow inside cells, needs colorGlow alpha > 0); `speed` = 0.4 (animation speed (0 = still)) - Paper shader `Voronoi` (animated). Install: `npx paper-motion add voronoi-glass` · https://paper-motion.vercel.app/r/voronoi-glass.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'voronoi-glass'); ``` ### Warp · ochre · `warp-ochre` Animated color fields warped by noise and swirls, applied over base patterns (checks, stripes, or split edge), in ochre. Params: `colors` = ["#0a0a0a","#C9A65A","#0a0a0a","#7A5A24"] (palette colors (hex)); `proportion` = 0.45 (Blend point between colors, 0.5 = equal distribution); `softness` = 1 (edge softness); `distortion` = 0.25 (amount of organic distortion); `swirl` = 0.8 (amount of swirl); `swirlIterations` = 10 (Number of layered swirl passes as an integer, needs swirl > 0); `shapeScale` = 0.1 (Zoom level of the base pattern); `shape` = "checks" (base pattern); `speed` = 0.5 (animation speed (0 = still)) - Paper shader `Warp` (animated). Install: `npx paper-motion add warp-ochre` · https://paper-motion.vercel.app/r/warp-ochre.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'warp-ochre'); ``` ### Water · `water` Water-like surface distortion with natural caustic realism. Params: `fit` = "cover" (How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)); `scale` = 1 (zoom of the pattern); `colorBack` = "#000000" (background color behind the effect); `colorHighlight` = "#ffffff" (Highlight color in RGBA, needs highlights > 0); `highlights` = 0.07 (Coloring added over image/background following caustic shape, needs colorHighlight alpha > 0); `layering` = 0.5 (Power of 2nd layer of caustic distortion, needs caustic or highlights > 0); `edges` = 0.8 (Caustic distortion power on the image edges, needs image and caustic > 0); `waves` = 0.3 (Additional distortion based on simplex noise, independent from caustic); `caustic` = 0.12 (Power of caustic distortion, needs image); `size` = 1 (dot or pattern size); `speed` = 0.6 (animation speed (0 = still)) - Paper shader `Water` (animated). - Uses an image (installed to brand/assets/materials/); swap `image` for your own picture or texture. Install: `npx paper-motion add water` · https://paper-motion.vercel.app/r/water.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'water'); ``` ### Waves · paper · `waves-paper` Static line pattern configurable into textures ranging from sharp zigzags to smooth flowing waves, in paper. Params: `colorFront` = "#E9E4D8" (foreground color); `colorBack` = "#000000" (background color behind the effect); `shape` = 1 (base pattern); `frequency` = 0.5 (Wave frequency, needs amplitude > 0); `amplitude` = 0.4 (Wave amplitude, at frequency = 0 it only shifts the lines); `spacing` = 1.4 (Space between every two wavy lines); `proportion` = 0.08 (Blend point between front and back colors, 0.5 = equal distribution); `softness` = 0.05 (edge softness); `scale` = 1 (zoom of the pattern) - Paper shader `Waves` (still). - Breathes on `amplitude` from 0.3 to 0.6 so a still shader stays alive. Install: `npx paper-motion add waves-paper` · https://paper-motion.vercel.app/r/waves-paper.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // a full-frame element
behind everything: B.shader(s, '#bg', 'waves-paper'); ``` ## Palettes ### Acid night · `acid-night` Dark palette: black with acid lime; loud, tech launch, nightlife. Params: `ground` = "#0B0B0A" (every frame); `figure` = "#F4F4EE" (primary type); `muted` = "#8C8C84" (secondary text); `surface` = "#161614" (panels and cards); `accent` = "#C8F04A" (one moment of emphasis); `ramp` = ["#0B0B0A","#2A2D1E","#7C9E25","#C8F04A"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 17.8:1, muted on ground 5.8:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add acid-night` · https://paper-motion.vercel.app/r/acid-night.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Clay desert · `clay-desert` Light palette: sand and terracotta; warm, human, craft. Params: `ground` = "#EADBC8" (every frame); `figure` = "#2B1D19" (primary type); `muted` = "#7A4E45" (secondary text); `surface` = "#E0CDB6" (panels and cards); `accent` = "#B07D73" (one moment of emphasis); `ramp` = ["#EADBC8","#D3A79A","#B07D73","#3F2925"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 12.0:1, muted on ground 5.1:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add clay-desert` · https://paper-motion.vercel.app/r/clay-desert.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Cobalt · `cobalt` Dark palette: ink blue with electric cobalt; product, software, confident. Params: `ground` = "#0A0F1F" (every frame); `figure` = "#EEF1F8" (primary type); `muted` = "#8590AE" (secondary text); `surface` = "#121933" (panels and cards); `accent` = "#3D6BFF" (one moment of emphasis); `ramp` = ["#0A0F1F","#1C2A55","#3D6BFF","#AFC2FF"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 16.9:1, muted on ground 6.0:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add cobalt` · https://paper-motion.vercel.app/r/cobalt.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Dusty rose · `dusty-rose` Light palette: pale blush with deep rose; soft, beauty, lifestyle. Params: `ground` = "#F3E9E4" (every frame); `figure` = "#2E1E1C" (primary type); `muted` = "#8C6660" (secondary text); `surface` = "#EADBD3" (panels and cards); `accent` = "#B07D73" (one moment of emphasis); `ramp` = ["#F3E9E4","#D9B3A5","#B07D73","#4A2E2A"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 13.3:1, muted on ground 4.2:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add dusty-rose` · https://paper-motion.vercel.app/r/dusty-rose.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Graphite · `graphite` Dark palette: pure black and white with greys; brutalist, technical. Params: `ground` = "#000000" (every frame); `figure` = "#FFFFFF" (primary type); `muted` = "#8A8A8A" (secondary text); `surface` = "#0A0A0A" (panels and cards); `accent` = "#E9E4D8" (one moment of emphasis); `ramp` = ["#000000","#2E2E2E","#5F7A86","#8EA3AD"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 21.0:1, muted on ground 6.1:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add graphite` · https://paper-motion.vercel.app/r/graphite.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Ink on paper · `ink-paper` Light palette: warm off-white paper with near-black ink; editorial and calm. Params: `ground` = "#ECE6D6" (every frame); `figure` = "#141311" (primary type); `muted` = "#6E685C" (secondary text); `surface` = "#E2DBC8" (panels and cards); `accent` = "#B5462E" (one moment of emphasis); `ramp` = ["#ECE6D6","#D8CFBA","#A39A86","#141311"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 14.9:1, muted on ground 4.4:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add ink-paper` · https://paper-motion.vercel.app/r/ink-paper.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Lavender ash · `lavender-ash` Light palette: cool lilac greys; gentle, wellness, modern. Params: `ground` = "#ECE9F0" (every frame); `figure` = "#221F29" (primary type); `muted` = "#7E7594" (secondary text); `surface` = "#E1DDE8" (panels and cards); `accent` = "#7E7594" (one moment of emphasis); `ramp` = ["#ECE9F0","#BDB4CB","#7E7594","#2E2A38"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 13.5:1, muted on ground 3.6:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add lavender-ash` · https://paper-motion.vercel.app/r/lavender-ash.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Mono light · `mono-light` Light palette: white and greys with black; neutral, minimal, documentation. Params: `ground` = "#FFFFFF" (every frame); `figure` = "#111111" (primary type); `muted` = "#777777" (secondary text); `surface` = "#F3F3F3" (panels and cards); `accent` = "#111111" (one moment of emphasis); `ramp` = ["#FFFFFF","#E5E5E5","#A3A3A3","#111111"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 18.9:1, muted on ground 4.5:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add mono-light` · https://paper-motion.vercel.app/r/mono-light.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Moss · `moss` Dark palette: forest greens on near-black; outdoors, sustainable. Params: `ground` = "#121510" (every frame); `figure` = "#E4EAD6" (primary type); `muted` = "#7F8F6A" (secondary text); `surface` = "#1B1F18" (panels and cards); `accent` = "#A7C080" (one moment of emphasis); `ramp` = ["#121510","#2A3324","#56664A","#A7C080"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 14.9:1, muted on ground 5.3:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add moss` · https://paper-motion.vercel.app/r/moss.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Navy on bone · `navy-bone` Light palette: bone white with ink navy; classic, editorial, banking. Params: `ground` = "#E9E3D3" (every frame); `figure` = "#14213D" (primary type); `muted` = "#5A6478" (secondary text); `surface` = "#DED7C4" (panels and cards); `accent` = "#C8553D" (one moment of emphasis); `ramp` = ["#E9E3D3","#A9B1C2","#4B5A7A","#14213D"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 12.5:1, muted on ground 4.6:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add navy-bone` · https://paper-motion.vercel.app/r/navy-bone.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Ochre sun · `ochre-sun` Light palette: cream with ochre and olive; sunny, optimistic, vintage. Params: `ground` = "#F1E8C9" (every frame); `figure` = "#2A2618" (primary type); `muted` = "#6F7A3A" (secondary text); `surface` = "#E8DDB6" (panels and cards); `accent` = "#B08A3E" (one moment of emphasis); `ramp` = ["#F1E8C9","#D8BC6E","#B08A3E","#3A3424"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 12.3:1, muted on ground 3.8:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add ochre-sun` · https://paper-motion.vercel.app/r/ochre-sun.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Plum and gold · `plum-gold` Dark palette: deep plum with antique gold; luxury, evening, editorial. Params: `ground` = "#1A1018" (every frame); `figure` = "#F1E6D8" (primary type); `muted` = "#9C8579" (secondary text); `surface` = "#24171F" (panels and cards); `accent` = "#C9A35B" (one moment of emphasis); `ramp` = ["#1A1018","#3B2234","#7A4B63","#C9A35B"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 15.1:1, muted on ground 5.3:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add plum-gold` · https://paper-motion.vercel.app/r/plum-gold.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Sage night · `sage-night` Dark palette: charcoal with sage greens; quiet, natural, premium. Params: `ground` = "#1E201C" (every frame); `figure` = "#E9EDCF" (primary type); `muted` = "#8FA67A" (secondary text); `surface` = "#272A24" (panels and cards); `accent` = "#C8D5A8" (one moment of emphasis); `ramp` = ["#1E201C","#2F3A2C","#5E7457","#A9B98A"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 13.7:1, muted on ground 6.2:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add sage-night` · https://paper-motion.vercel.app/r/sage-night.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Signal red · `signal-red` Light palette: white and black with a hard red; bold, Swiss, urgent. Params: `ground` = "#F5F3EF" (every frame); `figure` = "#0E0E0E" (primary type); `muted` = "#6B6B6B" (secondary text); `surface` = "#EAE7E1" (panels and cards); `accent` = "#E5322D" (one moment of emphasis); `ramp` = ["#F5F3EF","#C9C6C0","#6B6B6B","#0E0E0E"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 17.4:1, muted on ground 4.8:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add signal-red` · https://paper-motion.vercel.app/r/signal-red.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Slate sea · `slate-sea` Dark palette: deep blue-grey with cool slate; trustworthy, financial, calm. Params: `ground` = "#1C2226" (every frame); `figure` = "#E6ECEE" (primary type); `muted` = "#8FA3AD" (secondary text); `surface` = "#242C31" (panels and cards); `accent` = "#A9C7D3" (one moment of emphasis); `ramp` = ["#1C2226","#3E4E57","#6F8794","#A9B8BE"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 13.5:1, muted on ground 6.1:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add slate-sea` · https://paper-motion.vercel.app/r/slate-sea.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ### Terminal · `terminal` Dark palette: black with phosphor green; developer tools, CLI, retro. Params: `ground` = "#050805" (every frame); `figure` = "#D7F5D0" (primary type); `muted` = "#5F8F5A" (secondary text); `surface` = "#0C120C" (panels and cards); `accent` = "#4BE36A" (one moment of emphasis); `ramp` = ["#050805","#13301A","#2E8B45","#4BE36A"] (four steps from ground toward accent, for shaders and gradients) - Contrast: figure on ground 17.1:1, muted on ground 5.3:1. - Use the accent for one moment, not everywhere. Install: `npx paper-motion add terminal` · https://paper-motion.vercel.app/r/terminal.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); const s = scene({ background: B.color('ground') }); title.style.color = B.color('figure'); ``` ## Font pairs ### Archivo Black + Archivo · `archivo` Free font pair (Google Fonts): loud, poster, sports. Params: `display` = "Archivo Black" (headline family); `text` = "Archivo" (body family); `mono` = "JetBrains Mono" (labels and code family); `displayWeight` = 400 (headline weight); `tracking` = -0.02 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add archivo` · https://paper-motion.vercel.app/r/archivo.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### Bricolage Grotesque + Inter · `bricolage` Free font pair (Google Fonts): playful, expressive, consumer. Params: `display` = "Bricolage Grotesque" (headline family); `text` = "Inter" (body family); `mono` = "JetBrains Mono" (labels and code family); `displayWeight` = 700 (headline weight); `tracking` = -0.03 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add bricolage` · https://paper-motion.vercel.app/r/bricolage.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### DM Serif Display + DM Sans · `dm` Free font pair (Google Fonts): friendly, premium, lifestyle. Params: `display` = "DM Serif Display" (headline family); `text` = "DM Sans" (body family); `mono` = "DM Mono" (labels and code family); `displayWeight` = 400 (headline weight); `tracking` = -0.01 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add dm` · https://paper-motion.vercel.app/r/dm.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### Fraunces + Work Sans · `fraunces` Free font pair (Google Fonts): warm, characterful, food and craft. Params: `display` = "Fraunces" (headline family); `text` = "Work Sans" (body family); `mono` = "IBM Plex Mono" (labels and code family); `displayWeight` = 600 (headline weight); `tracking` = -0.02 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add fraunces` · https://paper-motion.vercel.app/r/fraunces.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### Geist + Geist Mono · `geist` Free font pair (Google Fonts): clean, technical, product. Params: `display` = "Geist" (headline family); `text` = "Geist" (body family); `mono` = "Geist Mono" (labels and code family); `displayWeight` = 600 (headline weight); `tracking` = -0.03 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add geist` · https://paper-motion.vercel.app/r/geist.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### Geist Serif + Geist + Geist Mono · `geist-serif` paper-motion.app's own pair: Geist Serif headlines (self-hosted), Geist text, Geist Mono labels; editorial and technical at once. Params: `display` = "Geist Serif" (headline family); `text` = "Geist" (body family); `mono` = "Geist Mono" (labels and code family); `displayWeight` = 400 (headline weight); `tracking` = -0.02 (headline letter spacing (em)) - Geist Serif is served by paper-motion.app (it is not on Google Fonts); renders need network, or copy /fonts/GeistSerif-Regular.woff2 into brand/assets/fonts and point the css at it. - Geist Serif ships in one weight (400). Install: `npx paper-motion add geist-serif` · https://paper-motion.vercel.app/r/geist-serif.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### Instrument Serif + Inter · `instrument` Free font pair (Google Fonts): editorial, elegant, contemporary. Params: `display` = "Instrument Serif" (headline family); `text` = "Inter" (body family); `mono` = "JetBrains Mono" (labels and code family); `displayWeight` = 400 (headline weight); `tracking` = -0.02 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add instrument` · https://paper-motion.vercel.app/r/instrument.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### Inter Tight + Inter · `inter-tight` Free font pair (Google Fonts): neutral, modern, UI-like. Params: `display` = "Inter Tight" (headline family); `text` = "Inter" (body family); `mono` = "JetBrains Mono" (labels and code family); `displayWeight` = 600 (headline weight); `tracking` = -0.03 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add inter-tight` · https://paper-motion.vercel.app/r/inter-tight.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### Playfair Display + Source Sans 3 · `playfair` Free font pair (Google Fonts): classic, luxury, magazine. Params: `display` = "Playfair Display" (headline family); `text` = "Source Sans 3" (body family); `mono` = "Source Code Pro" (labels and code family); `displayWeight` = 600 (headline weight); `tracking` = -0.01 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add playfair` · https://paper-motion.vercel.app/r/playfair.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### IBM Plex Serif + Plex Sans · `plex` Free font pair (Google Fonts): serious, corporate, documentation. Params: `display` = "IBM Plex Serif" (headline family); `text` = "IBM Plex Sans" (body family); `mono` = "IBM Plex Mono" (labels and code family); `displayWeight` = 500 (headline weight); `tracking` = -0.01 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add plex` · https://paper-motion.vercel.app/r/plex.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### Space Grotesk + Space Mono · `space` Free font pair (Google Fonts): quirky, tech, startup. Params: `display` = "Space Grotesk" (headline family); `text` = "Space Grotesk" (body family); `mono` = "Space Mono" (labels and code family); `displayWeight` = 600 (headline weight); `tracking` = -0.03 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add space` · https://paper-motion.vercel.app/r/space.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### Syne + Manrope · `syne` Free font pair (Google Fonts): artsy, bold, agency. Params: `display` = "Syne" (headline family); `text` = "Manrope" (body family); `mono` = "JetBrains Mono" (labels and code family); `displayWeight` = 700 (headline weight); `tracking` = -0.02 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add syne` · https://paper-motion.vercel.app/r/syne.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ### Unbounded + Inter · `unbounded` Free font pair (Google Fonts): futuristic, web3, wide. Params: `display` = "Unbounded" (headline family); `text` = "Inter" (body family); `mono` = "JetBrains Mono" (labels and code family); `displayWeight` = 600 (headline weight); `tracking` = -0.02 (headline letter spacing (em)) - Fonts load from Google Fonts at render time; for offline renders, download the files into brand/assets/fonts/ and set `file` instead of `css`. - Sizes are for a 1080 px short side; B.type() scales them for other formats. Install: `npx paper-motion add unbounded` · https://paper-motion.vercel.app/r/unbounded.json ```js import { loadBrand } from 'paper-motion/brand'; const B = await loadBrand(); // loads the fonts before the first frame B.style(title, 'display'); B.style(caption, 'caption'); ``` ## Recipes ### Before / after · `before-after` Two states of the same thing in one panel: the old one muted, a wipe, the new one in the brand's colors, then the close, in 16 s. Params: `beforeTag` = "Before" (label of the old state); `beforeLine` = "Forty minutes, three tools, one guess." (the old state, in one line); `beforeImage` = "" (a picture of the old state (path)); `afterTag` = "After" (label of the new state); `afterLine` = "One command. Every frame on purpose." (the new state, in one line); `afterImage` = "" (a picture of the new state (path)); `action` = "your.site" (the one action at the end); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work: pamo add sage-night instrument) and, for the background, a shader-set entry (pamo add mesh-sage). - A real picture of each state beats any panel; the before picture is shown desaturated. - Uses these moves from the engine: wipe, word-rise, blur-in, crossfade. Install: `npx paper-motion add before-after` · https://paper-motion.vercel.app/r/before-after.json ```js npx paper-motion add before-after --name my-piece # edit CONFIG in pieces/my-piece/scene.html, then: npx paper-motion render pieces/my-piece/scene.html --motion-blur 5 ``` ### End card · `end-card` The last 6 s of any piece: the wordmark arrives, one plain line, the action typed in, a hold. Params: `line` = "" (what the brand is; empty reads IDENTITY.md); `action` = "npx skills add your/brand" (URL, handle, date or command); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work: pamo add sage-night instrument) and, for the background, a shader-set entry (pamo add mesh-sage). - Structure and timing only; the look always comes from the brand. - Uses these moves from the engine: word-rise, blur-in, type-on. Install: `npx paper-motion add end-card` · https://paper-motion.vercel.app/r/end-card.json ```js npx paper-motion add end-card --name my-piece # edit CONFIG in pieces/my-piece/scene.html, then: npx paper-motion render pieces/my-piece/scene.html --motion-blur 5 ``` ### Explainer · `explainer` How something works in three steps on one card that changes state, with a recap and a close, in 36 s. Params: `question` = "How does it work?" (what this answers); `action` = "your.site" (the action at the end); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size); `step1Label` = "01" (step 1 label); `step1Title` = "First" (step 1 title); `step1Body` = "What happens first, in one line." (step 1 line); `step2Label` = "02" (step 2 label); `step2Title` = "Then" (step 2 title); `step2Body` = "The step that does the work." (step 2 line); `step3Label` = "03" (step 3 label); `step3Title` = "Done" (step 3 title); `step3Body` = "What you get at the end." (step 3 line) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work: pamo add sage-night instrument) and, for the background, a shader-set entry (pamo add mesh-sage). - Structure and timing only; the look always comes from the brand. - Uses these moves from the engine: push, magic-move, unfold, crossfade, word-rise, blur-in. Install: `npx paper-motion add explainer` · https://paper-motion.vercel.app/r/explainer.json ```js npx paper-motion add explainer --name my-piece # edit CONFIG in pieces/my-piece/scene.html, then: npx paper-motion render pieces/my-piece/scene.html --motion-blur 5 ``` ### Launch · `launch` Something new exists: hook, problem, reveal, three proof moments and a close, in 24 s. Params: `hook` = "Something new is here." (the boldest claim); `problem` = "The situation it changes, in the brand’s words." (the problem line); `what` = "" (what it is; empty reads IDENTITY.md); `action` = "your.site" (where to get it); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size); `proof1Label` = "01 · fast" (proof 1 label); `proof1Title` = "Fact one" (proof 1 title); `proof1Body` = "A real number or a real result." (proof 1 line); `proof2Label` = "02 · simple" (proof 2 label); `proof2Title` = "Fact two" (proof 2 title); `proof2Body` = "What it replaces, in one line." (proof 2 line); `proof3Label` = "03 · yours" (proof 3 label); `proof3Title` = "Fact three" (proof 3 title); `proof3Body` = "Who it is for, and why now." (proof 3 line) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work: pamo add sage-night instrument) and, for the background, a shader-set entry (pamo add mesh-sage). - Structure and timing only; the look always comes from the brand. - Uses these moves from the engine: zoom-through, flip-lift, whip-pan, flash, word-rise, blur-in, pop-in. Install: `npx paper-motion add launch` · https://paper-motion.vercel.app/r/launch.json ```js npx paper-motion add launch --name my-piece # edit CONFIG in pieces/my-piece/scene.html, then: npx paper-motion render pieces/my-piece/scene.html --motion-blur 5 ``` ### Manifesto · `manifesto` Words only: three statements in the brand's voice, each arriving its own way, a turn where one word becomes the name, then what it is and the action, in 18 s. Params: `statement1` = "Tools were made for hands." (statement one (under eight words)); `statement2` = "Agents have none." (statement two); `statement3` = "So we made the tool speak." (statement three); `what` = "" (what the brand is, in plain words; empty reads IDENTITY.md); `action` = "your.site" (the one action at the end); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work: pamo add sage-night instrument) and, for the background, a shader-set entry (pamo add mesh-sage). - Three statements, three entrances: never the same treatment twice. Keep each under eight words. - Uses these moves from the engine: word-rise, track-in, pop-in, scramble, blur-in. Install: `npx paper-motion add manifesto` · https://paper-motion.vercel.app/r/manifesto.json ```js npx paper-motion add manifesto --name my-piece # edit CONFIG in pieces/my-piece/scene.html, then: npx paper-motion render pieces/my-piece/scene.html --motion-blur 5 ``` ### Product demo · `product-demo` The real product, seen: three screenshots in one window under one camera (drift, punch, snap-scroll, whip), a caption each, in 22 s. Params: `what` = "" (what the brand is, in plain words; empty reads IDENTITY.md); `action` = "your.site" (the one action at the end); `background` = "" (a background id from the registry; empty uses the brand's first); `chrome` = "browser" (the window's frame); `format` = "1920x1080" (output size); `shot1Image` = "" (screenshot 1 (path); empty draws a placeholder UI); `shot1Caption` = "The overview: everything in one place." (what screen 1 proves); `shot2Image` = "" (screenshot 2 (path)); `shot2Caption` = "One click to the detail that matters." (what screen 2 proves); `shot3Image` = "" (screenshot 3 (path)); `shot3Caption` = "Numbers you can act on, as they change." (what screen 3 proves) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work: pamo add sage-night instrument) and, for the background, a shader-set entry (pamo add mesh-sage). - Made for real screenshots: without them each shot draws a placeholder UI in the brand's colors, so the structure can be judged first. - Uses these moves from the engine: mask-reveal, drift, punch, snap-scroll, whip-pan, flash, word-rise, blur-in. Install: `npx paper-motion add product-demo` · https://paper-motion.vercel.app/r/product-demo.json ```js npx paper-motion add product-demo --name my-piece # put the screenshots in, edit CONFIG in pieces/my-piece/scene.html, then: npx paper-motion render pieces/my-piece/scene.html --motion-blur 5 ``` ### README loop · `readme-loop` A silent 6 s loop for a repo or a landing hero: wordmark, one line, the install command typing and erasing. Params: `line` = "" (one plain line; empty reads IDENTITY.md); `command` = "npx skills add your/repo" (the install command); `background` = "" (a background id from the registry; empty uses the brand's first) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work: pamo add sage-night instrument) and, for the background, a shader-set entry (pamo add mesh-sage). - Structure and timing only; the look always comes from the brand. - Uses these moves from the engine: type-on. Install: `npx paper-motion add readme-loop` · https://paper-motion.vercel.app/r/readme-loop.json ```js npx paper-motion add readme-loop --name my-piece # edit CONFIG in pieces/my-piece/scene.html, then: npx paper-motion render pieces/my-piece/scene.html --motion-blur 5 ``` ### Release · `release` A record, a single, an episode: the cover art rises in, who and what, a pulse on the track's beat, the date and where to listen, in 15 s. Params: `title` = "Title" (the record, the single, the episode); `artist` = "" (who; empty uses the brand's name); `what` = "the debut EP" (what this is, in plain words); `action` = "Out 21 Nov · everywhere you listen" (the date and where to listen); `bpm` = 96 (the track's tempo: the cover and the bars move on it); `cover` = "" (the square cover art (path); empty fills the sleeve with the brand's shader); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1080x1080" (output size) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work: pamo add sage-night instrument) and, for the background, a shader-set entry (pamo add mesh-sage). - Made for a cover and a track: render with --audio; the pulse follows CONFIG.bpm, not the audio. - Uses these moves from the engine: word-rise, track-in, blur-in. Install: `npx paper-motion add release` · https://paper-motion.vercel.app/r/release.json ```js npx paper-motion add release --name my-piece # put the cover in, edit CONFIG in pieces/my-piece/scene.html, then: npx paper-motion render pieces/my-piece/scene.html --audio track.wav --loudness -14 ``` ### Social loop · `social-loop` A seamless 8 s loop for a feed: a living background, the brand and one line that comes and goes. Params: `line` = "One line in the brand’s voice." (the line that comes and goes); `what` = "" (name · what it is · where; empty builds it); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1080x1350" (output size); `text` = "" (how the line enters; empty follows motion.json) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work: pamo add sage-night instrument) and, for the background, a shader-set entry (pamo add mesh-sage). - Structure and timing only; the look always comes from the brand. - Uses these moves from the engine: word-rise, pop-in, blur-in. Install: `npx paper-motion add social-loop` · https://paper-motion.vercel.app/r/social-loop.json ```js npx paper-motion add social-loop --name my-piece # edit CONFIG in pieces/my-piece/scene.html, then: npx paper-motion render pieces/my-piece/scene.html --motion-blur 5 ``` ### Three things · `three-things` Three traits, features or reasons, each with its own mechanic: one rises, two pushes, three flips; a card with words and the brand's material (or a picture), then the close, in 22 s. Params: `intro` = "Three things to know." (the line under the name); `action` = "your.site" (the one action at the end); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size); `thing1Label` = "01" (the small label of thing 1); `thing1Title` = "Fast" (thing one); `thing1Body` = "A real number, a real result." (what it means, in one line); `thing1Image` = "" (a picture for it (path); empty uses the brand's material); `thing2Label` = "02" (the small label of thing 2); `thing2Title` = "Simple" (thing two); `thing2Body` = "What it replaces, in one line." (what it means); `thing2Image` = "" (a picture (path)); `thing3Label` = "03" (the small label of thing 3); `thing3Title` = "Yours" (thing three); `thing3Body` = "Who it is for, and why now." (what it means); `thing3Image` = "" (a picture (path)) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work: pamo add sage-night instrument) and, for the background, a shader-set entry (pamo add mesh-sage). - Three mechanics for three things (rise, push, flip): swap any of them for the moves the user chose. - Uses these moves from the engine: word-rise, pop-in, blur-in, push, flip-3d, crossfade. Install: `npx paper-motion add three-things` · https://paper-motion.vercel.app/r/three-things.json ```js npx paper-motion add three-things --name my-piece # edit CONFIG in pieces/my-piece/scene.html, then: npx paper-motion render pieces/my-piece/scene.html --motion-blur 5 ``` ## Shots ### Cursor guide · `cursor-guide` A cursor crosses a component on a curve, hovers the control that matters, clicks; the component answers and the camera leans in, in 5 s. Params: `image` = "" (the component (path); empty draws a placeholder UI); `button` = "Render" (the control it clicks (drawn when there is no image)); `answer` = "Rendering 720 frames…" (what the click reveals); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - `target` in CONFIG places the control as 0–1 across and down the component; with a real screenshot the drawn button hides and the cursor goes there. Install: `npx paper-motion add cursor-guide` · https://paper-motion.vercel.app/r/cursor-guide.json ```js npx paper-motion add cursor-guide --name my-shot # edit CONFIG in pieces/my-shot/scene.html, then: npx paper-motion render pieces/my-shot/scene.html --motion-blur 6 ``` ### Focus pull · `focus-pull` A close-up: a detail sharp and large, a title soft behind it; the focus pulls to the title as the camera eases back, in 4 s. Params: `detailText` = "0.2s" (the detail in focus first: a word or a number); `detailImage` = "" (or a picture for the detail (path)); `title` = "Every frame, on time." (what comes into focus behind it); `line` = "" (a small line under the title); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - The depth of field is real: `cam.focus()` from paper-motion/kit blurs by distance from the focal plane. Install: `npx paper-motion add focus-pull` · https://paper-motion.vercel.app/r/focus-pull.json ```js npx paper-motion add focus-pull --name my-shot # edit CONFIG in pieces/my-shot/scene.html, then: npx paper-motion render pieces/my-shot/scene.html --motion-blur 6 ``` ### Pass over · `pass-over` The camera glides across a component at a low angle, close and tilted at the edges, straight at the centre; a caption rides the pass, in 5 s. Params: `image` = "" (the component (path); empty draws a placeholder UI); `caption` = "One board. Every choice adds up." (the line that rides the pass); `direction` = "right" (enter from the left and leave right, or the reverse); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Only the camera moves; the component is still. Swap `image` for a real screenshot and the pass reads as a product shot. Install: `npx paper-motion add pass-over` · https://paper-motion.vercel.app/r/pass-over.json ```js npx paper-motion add pass-over --name my-shot # edit CONFIG in pieces/my-shot/scene.html, then: npx paper-motion render pieces/my-shot/scene.html --motion-blur 6 ``` ### Push in · `push-in` One word or the wordmark and a slow push of the camera onto it, the field sliding slower behind; a small line lands as it stops, in 4 s. Params: `word` = "" (the word; empty takes the brand's name); `line` = "paper-motion.app" (a small line that lands as the push stops); `closeness` = 0.62 (where the push stops: 1 fills the frame, 0.5 leaves air); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Parallax comes from the field scaling slower than the camera approaches. Install: `npx paper-motion add push-in` · https://paper-motion.vercel.app/r/push-in.json ```js npx paper-motion add push-in --name my-shot # edit CONFIG in pieces/my-shot/scene.html, then: npx paper-motion render pieces/my-shot/scene.html --motion-blur 6 ``` ### Turn in · `turn-in` An object arrives edge-first and turns to face the camera with a spring's overshoot; the camera answers with a small counter-move, in 3 s. Params: `image` = "" (the object's picture (path); empty draws a card in the brand's colors); `title` = "Boards" (on the drawn card); `label` = "01" (small, above the title); `ratio` = 1 (width / height: 1 a cover, 1.6 a card, 0.6 a phone); `from` = "left" (the edge it arrives from); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - The turn is a spring (`spring()` from paper-motion): stiffness and damping in the scene set the overshoot. Install: `npx paper-motion add turn-in` · https://paper-motion.vercel.app/r/turn-in.json ```js npx paper-motion add turn-in --name my-shot # edit CONFIG in pieces/my-shot/scene.html, then: npx paper-motion render pieces/my-shot/scene.html --motion-blur 6 ``` ## Blocks ### Bar grow · `bar-grow` Bars grow with a short overshoot as the camera passes low along the chart; the winner takes the accent and its number counts up. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `title` = "Renders per week" (title); `winner` = 6 (which bar (0-based) takes the accent); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add bar-grow` · https://paper-motion.vercel.app/r/bar-grow.json ```js npx paper-motion add bar-grow --name my-bar-grow # edit CONFIG in pieces/my-bar-grow/scene.html, then: npx paper-motion render pieces/my-bar-grow/scene.html --motion-blur 5 ``` ### Beat cuts · `beat-cuts` Every beat of the music is a hard cut to a new shot with a punch that decays; the first beat of a bar hits harder in the accent. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `bpm` = 120 (tempo: beats per minute (one word per beat; slower holds each word longer and makes the part longer)); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add beat-cuts` · https://paper-motion.vercel.app/r/beat-cuts.json ```js npx paper-motion add beat-cuts --name my-beat-cuts # edit CONFIG in pieces/my-beat-cuts/scene.html, then: npx paper-motion render pieces/my-beat-cuts/scene.html --motion-blur 5 ``` ### Browser frame · `browser-frame` The real product in a browser: the address types close up, the page loads and settles, the camera travels down it with pauses. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `image` = "" (a full-page screenshot of the product (tall); empty draws a stand-in page in the brand's colours); `url` = "your-product.com" (url); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add browser-frame` · https://paper-motion.vercel.app/r/browser-frame.json ```js npx paper-motion add browser-frame --name my-browser-frame # edit CONFIG in pieces/my-browser-frame/scene.html, then: npx paper-motion render pieces/my-browser-frame/scene.html --motion-blur 5 ``` ### Callout zoom · `callout-zoom` A ring pulses on a detail too small to read; a round lens grows out of it and shows it magnified, tied back by a thin line. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `detail` = 2 (which row the lens magnifies); `zoom` = 2.8 (how much the lens magnifies); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add callout-zoom` · https://paper-motion.vercel.app/r/callout-zoom.json ```js npx paper-motion add callout-zoom --name my-callout-zoom # edit CONFIG in pieces/my-callout-zoom/scene.html, then: npx paper-motion render pieces/my-callout-zoom/scene.html --motion-blur 5 ``` ### Circle mark · `circle-mark` A hand-drawn ring closes around the number that matters on a screen; the rest dims, the marked card lifts and the camera leans in close. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `mark` = 1 (which stat gets the ring); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add circle-mark` · https://paper-motion.vercel.app/r/circle-mark.json ```js npx paper-motion add circle-mark --name my-circle-mark # edit CONFIG in pieces/my-circle-mark/scene.html, then: npx paper-motion render pieces/my-circle-mark/scene.html --motion-blur 5 ``` ### Code diff · `code-diff` The old lines strike through and fold away, one new line opens in their place, the numbers close up and a −7 +1 count lands. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `file` = "make-video.js" (file); `fps` = 30 (fps); `codec` = "libx264" (codec); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add code-diff` · https://paper-motion.vercel.app/r/code-diff.json ```js npx paper-motion add code-diff --name my-code-diff # edit CONFIG in pieces/my-code-diff/scene.html, then: npx paper-motion render pieces/my-code-diff/scene.html --motion-blur 5 ``` ### Code type · `code-type` Code writes itself in an editor in the brand's colours; the camera rides the caret close, then the line that matters lights up. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `file` = "scene.js" (file); `highlight` = 5 (the line (1-based) that lights up at the end); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add code-type` · https://paper-motion.vercel.app/r/code-type.json ```js npx paper-motion add code-type --name my-code-type # edit CONFIG in pieces/my-code-type/scene.html, then: npx paper-motion render pieces/my-code-type/scene.html --motion-blur 5 ``` ### Device frame · `device-frame` A phone with real thickness, the product scrolling on its screen; the camera orbits round it from the side to face-on. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `image` = "" (a screenshot of the app (tall); empty draws the placeholder app); `title` = "Renders" (title); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add device-frame` · https://paper-motion.vercel.app/r/device-frame.json ```js npx paper-motion add device-frame --name my-device-frame # edit CONFIG in pieces/my-device-frame/scene.html, then: npx paper-motion render pieces/my-device-frame/scene.html --motion-blur 5 ``` ### Dither dissolve · `dither-dissolve` One shot breaks into an ordered dither, dot by dot, in a sweep across the frame; the edge lights in the accent and the next shot is under it. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `a` = "Tools were made for hands." (a); `b` = "" (the name it dissolves into (empty: the brand's name)); `bLine` = "Brand videos, made by your coding agent." (bLine); `cell` = 14 (the dither's dot size, in pixels at 1080p); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add dither-dissolve` · https://paper-motion.vercel.app/r/dither-dissolve.json ```js npx paper-motion add dither-dissolve --name my-dither-dissolve # edit CONFIG in pieces/my-dither-dissolve/scene.html, then: npx paper-motion render pieces/my-dither-dissolve/scene.html --motion-blur 5 ``` ### Donut fill · `donut-fill` A ring fills to its percentage as the number counts, rising from a tilted view to face-on, and a pulse rings out when it lands. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `value` = 87 (the percentage); `label` = "of renders pass on the first try" (label); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add donut-fill` · https://paper-motion.vercel.app/r/donut-fill.json ```js npx paper-motion add donut-fill --name my-donut-fill # edit CONFIG in pieces/my-donut-fill/scene.html, then: npx paper-motion render pieces/my-donut-fill/scene.html --motion-blur 5 ``` ### Drag and drop · `drag-drop` A cursor lifts a card on a board, carries it tilted to another column, a slot opens, it drops on a spring and the counts update. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add drag-drop` · https://paper-motion.vercel.app/r/drag-drop.json ```js npx paper-motion add drag-drop --name my-drag-drop # edit CONFIG in pieces/my-drag-drop/scene.html, then: npx paper-motion render pieces/my-drag-drop/scene.html --motion-blur 5 ``` ### Form fill · `form-fill` A cursor fills a form field by field, each check pops on, the button works and then opens into a new, black screen. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `title` = "New brand" (title); `button` = "Create brand" (button); `done` = "Created" (done); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add form-fill` · https://paper-motion.vercel.app/r/form-fill.json ```js npx paper-motion add form-fill --name my-form-fill # edit CONFIG in pieces/my-form-fill/scene.html, then: npx paper-motion render pieces/my-form-fill/scene.html --motion-blur 5 ``` ### Grain pulse · `grain-pulse` On each hit the grain swells, the colour channels split for a moment and the frame punches in, then it all settles until the next. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `last` = "" (the last word; empty takes the brand's name); `grain` = 0.1 (the quiet grain between hits); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add grain-pulse` · https://paper-motion.vercel.app/r/grain-pulse.json ```js npx paper-motion add grain-pulse --name my-grain-pulse # edit CONFIG in pieces/my-grain-pulse/scene.html, then: npx paper-motion render pieces/my-grain-pulse/scene.html --motion-blur 5 ``` ### Kinetic captions · `kinetic-captions` Captions timed to a voice: the phrase sits dim, each word lights as it is said, key words land bigger, phrases change on a clean cut. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `script` = "Your agent writes the brief. You pick the look. It renders every frame. That is paper-motion." (script); `perPage` = 24 (most characters on one page of captions); `format` = "1080x1920" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add kinetic-captions` · https://paper-motion.vercel.app/r/kinetic-captions.json ```js npx paper-motion add kinetic-captions --name my-kinetic-captions # edit CONFIG in pieces/my-kinetic-captions/scene.html, then: npx paper-motion render pieces/my-kinetic-captions/scene.html --motion-blur 5 ``` ### Light sweep · `light-sweep` A card turns in the light and a diagonal glint crosses its face in step with the turn, its edge catching a thin line. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `title` = "" (empty takes the brand's name); `line` = "Release 0.2.6" (line); `corner` = "paper-motion.app" (corner); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add light-sweep` · https://paper-motion.vercel.app/r/light-sweep.json ```js npx paper-motion add light-sweep --name my-light-sweep # edit CONFIG in pieces/my-light-sweep/scene.html, then: npx paper-motion render pieces/my-light-sweep/scene.html --motion-blur 5 ``` ### Line draw · `line-draw` A trend line draws with a dot riding its tip and the camera close on it; at the peak a label pops and the camera pulls back on the climb. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `title` = "Brands made with paper-motion" (title); `tag` = "+42% this month" (tag); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add line-draw` · https://paper-motion.vercel.app/r/line-draw.json ```js npx paper-motion add line-draw --name my-line-draw # edit CONFIG in pieces/my-line-draw/scene.html, then: npx paper-motion render pieces/my-line-draw/scene.html --motion-blur 5 ``` ### A sentence · `line-in` One sentence in the brand's display type, arriving in one of eight entrances; the words that carry it land in the accent. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `text` = "Video editing without the timeline" (the sentence); `mark` = "without the timeline" (the words that land in the accent); `entrance` = "rise" (how it arrives); `align` = "center" (where it sits); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. - The entrance is a setting: a piece may hold several sentences, each arriving its own way (the planner gives each one a different entrance unless the user chose). Install: `npx paper-motion add line-in` · https://paper-motion.vercel.app/r/line-in.json ```js npx paper-motion add line-in --name my-line # edit CONFIG in pieces/my-line/scene.html, then: npx paper-motion render pieces/my-line/scene.html --motion-blur 5 ``` ### Logo build · `logo-build` The wordmark builds itself: each letter traces its outline, the fill rises from the baseline, and the domain lands under it. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `word` = "" (empty takes the brand's wordmark); `domain` = "paper-motion.app" (domain); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add logo-build` · https://paper-motion.vercel.app/r/logo-build.json ```js npx paper-motion add logo-build --name my-logo-build # edit CONFIG in pieces/my-logo-build/scene.html, then: npx paper-motion render pieces/my-logo-build/scene.html --motion-blur 5 ``` ### Marker highlight · `marker-highlight` A sentence lands word by word, then a tilted marker sweeps behind the key words, which turn dark exactly where it passes. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `before` = "Your agent directs" (before); `mark` = "every frame." (the words the marker sweeps); `after` = "" (after); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add marker-highlight` · https://paper-motion.vercel.app/r/marker-highlight.json ```js npx paper-motion add marker-highlight --name my-marker-highlight # edit CONFIG in pieces/my-marker-highlight/scene.html, then: npx paper-motion render pieces/my-marker-highlight/scene.html --motion-blur 5 ``` ### Parallax stack · `parallax-stack` An interface pulled apart into solid layers in depth; the camera orbits so each slides at its own speed, then they fall flat into one screen. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `depth` = 1 (how far apart the layers float, 1 = default); `thickness` = 1 (how thick each component is, 0 for flat cards); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add parallax-stack` · https://paper-motion.vercel.app/r/parallax-stack.json ```js npx paper-motion add parallax-stack --name my-parallax-stack # edit CONFIG in pieces/my-parallax-stack/scene.html, then: npx paper-motion render pieces/my-parallax-stack/scene.html --motion-blur 5 ``` ### Pointer label · `pointer-label` A short line lands on the screen, a curved arrow draws from it to a control, and the control answers with a pulse. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `label` = "One click renders it all." (the line the arrow starts from); `button` = "Render" (the control the arrow points at); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add pointer-label` · https://paper-motion.vercel.app/r/pointer-label.json ```js npx paper-motion add pointer-label --name my-pointer-label # edit CONFIG in pieces/my-pointer-label/scene.html, then: npx paper-motion render pieces/my-pointer-label/scene.html --motion-blur 5 ``` ### Search type · `search-type` A command palette opens, the query types fast, the list filters live with the matches underlined and the top result is chosen. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `placeholder` = "Search resources…" (placeholder); `query` = "push" (query); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add search-type` · https://paper-motion.vercel.app/r/search-type.json ```js npx paper-motion add search-type --name my-search-type # edit CONFIG in pieces/my-search-type/scene.html, then: npx paper-motion render pieces/my-search-type/scene.html --motion-blur 5 ``` ### Stat compare · `stat-compare` The old number is struck through and falls away soft; the new one arrives from deep in the scene and lands in the accent. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `label` = "per launch video" (label); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add stat-compare` · https://paper-motion.vercel.app/r/stat-compare.json ```js npx paper-motion add stat-compare --name my-stat-compare # edit CONFIG in pieces/my-stat-compare/scene.html, then: npx paper-motion render pieces/my-stat-compare/scene.html --motion-blur 5 ``` ### Stat row · `stat-row` Three numbers count up in turn with rules drawing between them; the camera meets each as it counts, then pulls back to all three. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add stat-row` · https://paper-motion.vercel.app/r/stat-row.json ```js npx paper-motion add stat-row --name my-stat-row # edit CONFIG in pieces/my-stat-row/scene.html, then: npx paper-motion render pieces/my-stat-row/scene.html --motion-blur 5 ``` ### SVG logo · `svg-logo` The brand's own SVG logo draws on: outlines trace in the accent, shapes fill from their centre, a glint passes and the name lands beside it. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `name` = "" (the name beside the mark; empty takes the brand's name, 'none' for the mark alone); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add svg-logo` · https://paper-motion.vercel.app/r/svg-logo.json ```js npx paper-motion add svg-logo --name my-svg-logo # edit CONFIG in pieces/my-svg-logo/scene.html, then: npx paper-motion render pieces/my-svg-logo/scene.html --motion-blur 5 ``` ### Terminal run · `terminal-run` A command types itself, a spinner works, the output streams in with its checks and the file it made lights up. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `cwd` = "~/launch" (cwd); `command` = "npx paper-motion add push-in" (command); `working` = "Resolving push-in" (working); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add terminal-run` · https://paper-motion.vercel.app/r/terminal-run.json ```js npx paper-motion add terminal-run --name my-terminal-run # edit CONFIG in pieces/my-terminal-run/scene.html, then: npx paper-motion render pieces/my-terminal-run/scene.html --motion-blur 5 ``` ### Liquid metal word · `text-mask` The name in rounded, sharp-edged liquid metal; the camera travels along the letters close, then pulls back to the whole word. Params: `word` = "" (empty takes the brand's name); `line` = "Brand videos, made by your coding agent." (line); `weight` = 3 (extra stroke on the letters, in px at 400px type: 0 keeps the face's own weight); `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add text-mask` · https://paper-motion.vercel.app/r/text-mask.json ```js npx paper-motion add text-mask --name my-text-mask # edit CONFIG in pieces/my-text-mask/scene.html, then: npx paper-motion render pieces/my-text-mask/scene.html --motion-blur 5 ``` ### Toast stack · `toast-stack` Notifications arrive in a corner one after another and push the older ones back into a stack; the last carries the accent. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add toast-stack` · https://paper-motion.vercel.app/r/toast-stack.json ```js npx paper-motion add toast-stack --name my-toast-stack # edit CONFIG in pieces/my-toast-stack/scene.html, then: npx paper-motion render pieces/my-toast-stack/scene.html --motion-blur 5 ``` ### Toggle flip · `toggle-flip` A cursor flips a switch and the whole interface changes theme in a circle that spreads out from the switch. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `title` = "Appearance" (title); `toggle` = "Light mode" (toggle); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add toggle-flip` · https://paper-motion.vercel.app/r/toggle-flip.json ```js npx paper-motion add toggle-flip --name my-toggle-flip # edit CONFIG in pieces/my-toggle-flip/scene.html, then: npx paper-motion render pieces/my-toggle-flip/scene.html --motion-blur 5 ``` ### Word swap · `word-swap` One word in a sentence keeps changing, rolling out and in, while the rest of the sentence makes room for each new width. Params: `background` = "" (a background id from the registry; empty uses the brand's first); `before` = "Make a " (before); `after` = " video." (after); `format` = "1920x1080" (output size; the layout recomposes for each) - Wired to the brand folder: needs brand/tokens.json (a palette and a font pair work) and, for the field, a shader-set entry. - Recomposes for 16:9, 9:16 and 1:1: set `format` and the layout and camera follow. Install: `npx paper-motion add word-swap` · https://paper-motion.vercel.app/r/word-swap.json ```js npx paper-motion add word-swap --name my-word-swap # edit CONFIG in pieces/my-word-swap/scene.html, then: npx paper-motion render pieces/my-word-swap/scene.html --motion-blur 5 ```