line-art-animation
Build animated line-art components in SVG and TypeScript — thin ink lines on paper, people and animals that walk, run, cycle and react, scenes with wind, lit windows and a day/night cycle, exported to video if needed. Use this whenever someone asks for a line art (or ink, pen, doodle, hand-drawn) animation, an animated illustration or scene component, little characters doing everyday things, a living street/village/shop/park, a day-night cycle illustration, "make it like this clip" for a drawn animation, or a video of such a component — even if they never say "SVG" or "line art".
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Badge for your README
Markdown
[](/listings/jdhruv14--line-art-animation)HTML
<a href="/listings/jdhruv14--line-art-animation"><img src="/api/listings/jdhruv14--line-art-animation/badge.svg" alt="findsafeskills safety rating" /></a>Install
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
For Claude Code, clone it into your skills folder:
git clone https://github.com/JDhruv14/line-art-animation ~/.claude/skills/line-art-animation
or into `.claude/skills/` inside a single project. Then ask for what you want, for example:
- "Make a line art animation of a bakery at dawn: a baker carrying trays, steam from the oven, a cat in the window." - "Turn this clip into a looping line-art component, matching its walk exactly." (attach or link the clip) - "Add a day-night cycle to the scene and render a 30-second 1080p video."
Claude reads `SKILL.md`, copies `lib/` into your project, shows one figure for approval before building the rest, and checks motion frame by frame before handing it over.
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
SKILL.md · Manifest · 97 lines
- ---
- name: line-art-animation
- description: Build animated line-art components in SVG and TypeScript — thin ink lines on paper, people and animals that walk, run, cycle and react, scenes with wind, lit windows and a day/night cycle, exported to video if needed. Use this whenever someone asks for a line art (or ink, pen, doodle, hand-drawn) animation, an animated illustration or scene component, little characters doing everyday things, a living street/village/shop/park, a day-night cycle illustration, "make it like this clip" for a drawn animation, or a video of such a component — even if they never say "SVG" or "line art".
- ---
- # Line-art animation
- Animated illustration components: everything is drawn with one thin pen on paper,
- built live in SVG from TypeScript, so it stays crisp at any size, responds to the
- pointer, and can be stepped frame by frame for checking or video export.
- This skill ships a small library (`lib/`), two examples (`examples/walker`, a single
- figure in ~150 lines; `examples/village`, a full scene) and tools (`scripts/`).
- Read the example that's closest to the request before writing anything.
- ## How people judge this work
- They look at it like an animator would: frame by frame, at zoom, against life or
- against a reference. These were all rejected in practice, and each has a rule below:
- - walks that bob on a sine wave, feet that slide, gaits sped up to fit a time-lapse
- - limbs drawn as closed tubes; ruler-straight lines; rigid clothes that ignore the legs
- - a whole set of components built in one go that all look alike ("AI slop")
- - interactions that feel like UI instead of the world reacting
- - a page whose background changes with the scene ("looks like a video, not a component")
- - reusing characters from a reference clip when asked for something new
- - leftover props nobody asked for (they asked to remove hanging laundry)
- ## Workflow
- 1. **Pin the look** before anything moves. Read `references/style.md`. Decide the pen
- weight, paper colour, figure proportions and the one or two flat accent colours.
- 2. **Set up the project.** Copy `lib/` into the project (it's four dependency-free
- `.ts` files) and use Vite + TypeScript (`package.json`, `tsconfig.json` and
- `vite.config.ts` in this repo show the setup). Components are plain DOM/SVG — no framework needed.
- 3. **Build one figure or one corner first** and show it (screenshot or a short clip,
- next to the reference if there is one). Get a yes before building the rest. A
- full set built at once comes back as generic; one good piece shows the bar.
- 4. **Make it move** with `references/motion.md`: `gait()` for walking and running,
- `spring()` / `pendulum()` for anything attached or hanging, keyed poses with
- `curve()` or `sequence()` for gestures. Never animate a figure with free sines.
- 5. **Compose the scene** with `references/scenes.md`: a self-contained card on a fixed
- page background, layers, a time-of-day palette from `lib/daynight.ts`, lights,
- wind, people arriving on schedules, interactions that are reactions.
- 6. **Verify** with `references/verify.md` before showing anything: typecheck,
- `?debug` stepping, zoomed frame strips of every moving thing, interactions
- triggered and stepped through, 60 fps in a real tab.
- 7. **If there's a reference clip to match**, follow `references/matching.md` — measure
- timing and poses from the clip instead of guessing, and check with an overlay.
- 8. **If they want a video**, follow `references/video.md` (deterministic headless
- capture with `scripts/capture.ts`, then ffmpeg).
- ## Rules that make it work
- - **Limbs are two open strokes.** `limb()` draws a paper-filled band between two pen
- lines that stop short of each other at the far end. This is the style's signature.
- - **Lines curve.** Joints are rounded, edges bow slightly, nothing is ruler-straight.
- - **Draw each figure in its own space** — ~95 units tall, feet on y = 120, facing +x,
- standing at x = 40 — and place it with `place(g, x, y, dir, scale)`. Proportions,
- pen weight and the gait presets all assume this space.
- - **Clothes are drawn around the skeleton.** Solve the legs (even if hidden), then
- draw the coat or kimono hem from the forward knee and the ankles so the cloth opens
- and closes with the stride. Sleeves, scarves and bags swing on springs.
- - **Feet are planted.** Move a walker by exactly `gait.speed × scale` per second and
- the stance foot stays still on the ground. Don't speed a gait up to match a
- compressed clock; compress arrivals instead.
- - **Ink is `currentColor`, paper is `.pp`.** Retint the whole drawing with
- `applyPalette()` (day: dark ink on warm paper; night: pale ink on indigo, warm
- windows). Solid-colour limb fills must use `solid()`, or the paper CSS wins.
- - **The component is a card.** The page around it never changes colour.
- - **Interactions are the world reacting**: a person bows or tips a hat, a cat wakes and
- stretches, a lantern swings, birds scatter, a fish jumps. Pointer movement is wind.
- No buttons inside the scene; a single faint hint line is enough.
- - **New means new.** If the brief is "like this but new", keep the medium, pen,
- proportions and timing feel; invent the characters, activities and props.
- ## Library at a glance
- | module | what it gives you |
- |---|---|
- | `lib/ink.ts` | `pen` `shape` `blot` `paint` `limb` `solid` `joint` `hang` `curve` `shoe` `place` `toScene` `inkDefs` `run` |
- | `lib/gait.ts` | `gait({ kind: 'walk' \| 'shuffle' \| 'run', …overrides })` → `{ speed, period, pose(phase, go) }` |
- | `lib/motion.ts` | `spring` `pendulum` `pointerWind` `sequence` `seeded` `wobble` `ease` `minJerk` … |
- | `lib/daynight.ts` | `palette(τ)` → sky, paper, ink, `lamp`, `night`, `sunset`; `applyPalette` `nightTint` |
- `run(draw)` drives everything with `draw(t, dt)`. Two URL flags matter for checking:
- `?t=1.25` freezes time; `?debug` disables rAF and exposes `window.__step(seconds)`
- for exact stepping (background and headless tabs throttle rAF, so always verify in debug mode).
- ## Scripts
- - `scripts/capture.ts <url?debug> <outDir> <frames> <fps> [w] [h] [setupJs] [frameJs]` — deterministic PNG frames from headless Chrome
- - `scripts/clip.ts period|blobs …` — loop length of a region; dark-blob tracking per frame
- - `scripts/frames.sh <clip> x y w h outDir` — grid-overlaid frames for reading poses off a clip
- All run with Node ≥ 22.18 (TypeScript is stripped natively) plus ffmpeg; `capture.ts`
- finds a local Chrome/Chromium or uses `$CHROME`.
README.md · README · 134 lines
- # line-art-animation
- A Claude skill and a small TypeScript library for animated line-art components:
- ink-on-paper figures that walk, ride and react, in scenes that run from day to night.
- Everything is drawn live in SVG, so it stays sharp at any size and responds to the
- pointer.
- 
- | Day | Night |
- |---|---|
- |  |  |
- ## What's in the repo
- | | |
- |---|---|
- | `SKILL.md`, `references/` | The skill: workflow, the rules that make the style work, and guides for style, motion, scenes, verification, matching a reference clip and rendering video. |
- | `lib/` | Four dependency-free TypeScript modules: drawing primitives (`ink.ts`), a walk/run solver (`gait.ts`), springs, pendulums and wind (`motion.ts`), and a time-of-day palette (`daynight.ts`). |
- | `examples/walker/` | One figure in about 150 lines: a man with a briefcase walks across the card; click him and he tips his hat. |
- | `examples/village/` | A full scene: a street of machiya, a tea house and a bath house by a canal, villagers on schedules, a cat, birds, a boatman, lit windows and reflections, about a dozen interactions. |
- | `scripts/` | Deterministic frame capture for video, and tools for measuring a reference clip. |
- ## Install the skill
- For Claude Code, clone it into your skills folder:
- ```sh
- git clone https://github.com/JDhruv14/line-art-animation ~/.claude/skills/line-art-animation
- ```
- or into `.claude/skills/` inside a single project. Then ask for what you want, for example:
- - "Make a line art animation of a bakery at dawn: a baker carrying trays, steam from the oven, a cat in the window."
- - "Turn this clip into a looping line-art component, matching its walk exactly." (attach or link the clip)
- - "Add a day-night cycle to the scene and render a 30-second 1080p video."
- Claude reads `SKILL.md`, copies `lib/` into your project, shows one figure for approval
- before building the rest, and checks motion frame by frame before handing it over.
- ## Run the examples
- Requires Node 22.18 or newer.
- ```sh
- npm install
- npm run dev # http://localhost:5173
- ```
- In the village, drag the sun or moon across the sky to change the time, move the pointer
- to make wind, and click people, windows, lanterns, the wind chime, the cat, the birds or
- the water. URL flags: `?start=0.9` sets the starting time (0 is midnight, 0.5 noon),
- `?tau=0.5` pins it, `?day=30` makes a full day last 30 seconds, `?debug` steps time by hand.
- ```sh
- npm run typecheck # strict for lib/ and the walker
- npm run build
- ```
- ## The library in brief
- 
- Figures are drawn in their own space, about 95 units tall with feet on y = 120, and placed
- into a scene with a transform. Limbs are two open pen strokes around a curve through the
- joints, which is most of what makes the drawing read as hand-inked.
- A complete program that draws a pair of legs walking across the page (the walker
- example adds the body, arms, clothes and the click reaction):
- ```ts
- import { el, limb, shoe, place, inkDefs, run } from './lib/ink.ts';
- import { gait } from './lib/gait.ts';
- const svg = el('svg', { viewBox: '0 0 480 240' });
- document.body.append(svg);
- const fig = el('g', { filter: inkDefs(svg).filter }, svg);
- const legs = [limb(fig, 4.2), limb(fig, 4.2)];
- const shoes = [el('path', {}, fig), el('path', {}, fig)];
- const walk = gait({ kind: 'walk' });
- let phase = 0, x = 60;
- run((t, dt) => {
- phase += dt / walk.period;
- x += walk.speed * 1.25 * dt; // move at the gait's speed and the feet stay planted
- place(fig, x % 520 - 20, 196, 1, 1.25);
- const p = walk.pose(phase);
- p.feet.forEach((foot, i) => {
- legs[i].draw([p.hip, foot.knee, foot.ankle]);
- shoe(shoes[i], foot.ankle, foot.pitch);
- });
- });
- ```
- `gait()` solves the legs rather than animating them: the planted foot slides back at
- exactly the travel speed, the swing follows a minimum-jerk path, the heel peels off the
- toe before each step, and hip height comes from what the planted legs can reach, so the
- body rises over each step and dips when both feet are down. Clothes are then drawn
- around the knees and ankles, so a coat or kimono opens and closes with the stride.
- `palette(τ)` gives sky, paper and ink colours for any time of day. Ink is `currentColor`
- and paper fills carry a `pp` class, so `applyPalette()` can turn the whole drawing into
- pale ink on indigo at night while windows and lanterns glow.
- ## Render a video
- ```sh
- npm run dev
- node scripts/capture.ts "http://localhost:5173/examples/village/?debug&capture&day=30&start=0.3" \
- captures/village 900 30 1920 1080
- ffmpeg -framerate 30 -i captures/village/f%04d.png -c:v libx264 -preset slow -crf 15 \
- -pix_fmt yuv420p -movflags +faststart -tune animation village.mp4
- ```
- The capture script drives headless Chrome over the DevTools protocol, with no npm
- dependencies, and advances the scene by exactly one frame between screenshots, so the
- result doesn't depend on machine speed. It finds a local Chrome or Chromium, or uses
- `$CHROME`. Needs ffmpeg.
- ## Match a reference clip
- ```sh
- node scripts/clip.ts period clip.mp4 X Y W H # loop length of a region
- node scripts/clip.ts blobs clip.mp4 X Y W H Y0 Y1 # dark blobs per frame, e.g. feet
- scripts/frames.sh clip.mp4 X Y W H out/ # frames with a measuring grid
- ```
- `references/matching.md` covers the rest: why to resample by time (most social clips
- are variable-frame-rate), reading poses off the grid, and an overlay mode for checking
- your drawing against the clip.
- ## License
- MIT
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.