Przejdź do treści
Biblioteka skilli
Marketing i treści · Budowanie i kod

animate

/animate

Tworzy gotową krótką animację rysowaną w kodzie z syntetyczną ścieżką dźwiękową, na podstawie obrazów referencyjnych i pomysłu.

Repozytorium
animate-skill ↗
Licencja
MIT
Ostatnia zmiana repozytorium
07.11.2026

Ocena i bezpieczeństwo

95/ 100Klasa: dobry
Format20 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
5
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 07.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Tworzy gotową krótką animację rysowaną w kodzie z syntetyczną ścieżką dźwiękową, na podstawie obrazów referencyjnych i pomysłu.

Wyzwalacze z opisu

drawn with code
Oryginalny opis (EN)

Make a finished short animation drawn entirely in code, with a synthesized soundtrack, from any number of reference images or videos plus a rough idea. Three jobs: animate a still image the user supplies, repaint a reference as a moving scene, or make a new film on a topic in the look of the references (explainers, animated stories, motion graphics, loops). Use whenever the user shares a reference image or video and says animate this, bring it to life, make it move, make something like this, in this style, or asks for an animated explainer or story "drawn with code" or without AI video models,

Jak działa

  1. Pick the job
  2. Stage 1: Study every reference
  3. Stage 2: Beats
  4. Stage 3: Build the picture
  5. Stage 4: Sound
  6. Stage 5: Render, check, fix
  7. Hand over
Sekcje z nagłówków SKILL.md, w oryginale · 161 linii, 1 351 słów
Podgląd SKILL.md
---
name: animate
description: >-
  Make a finished short animation drawn entirely in code, with a synthesized soundtrack, from any number of
  reference images or videos plus a rough idea. Three jobs: animate a still image the user supplies, repaint a
  reference as a moving scene, or make a new film on a topic in the look of the references (explainers, animated
  stories, motion graphics, loops). Use whenever the user shares a reference image or video and says animate this,
  bring it to life, make it move, make something like this, in this style, or asks for an animated explainer or
  story "drawn with code" or without AI video models, even if they never say "skill". Prefer this over video-studio
  when the look of the animation is the point rather than a narrated reel.
---

# animate

Turn references and a rough idea into an MP4 where every frame is drawn by code and the sound is synthesized.
The user brings taste; you do the directing. A rough brief is enough, so make the creative calls yourself and ask
only about what would change the whole piece.

Everything lives in `animations/<slug>/`:

```
refs/  study/  style.md  beats.md  piece.html  score.json  out/<slug>.mp4
```

Add helper scripts or notes there as needed. `examples/bee-dance/` in this skill's folder is a complete worked film.

In the commands below, `$SKILL` means this skill's folder. Run them from the user's project with `$SKILL/.venv/bin/python`
if that exists, otherwise `python3`. If a package is missing, see the setup in `README.md`. They need ffmpeg and Chrome.

## Pick the job

| The user wants | Job | How |
| --- | --- | --- |
| "Animate this image" | **Move the artwork** | Cut the image into layers and move those. Read `references/move-an-image.md`. Skip stages 3-4's piece.html; the render is a Python script. |
| "Paint this", "recreate this scene" | **Repaint** | Draw the whole scene in `piece.html`, matching the reference closely. |
| A topic or story "in this style" | **New film** | Full process below. References set the look; the subject is new. |

If they don't name a length or shape, use 15 seconds at 1080x1920 for a film and 5 seconds for a moving image.

Code is strong at shapes, lines, gradients and texture: flat vector, line art, paper-cut, risograph, watercolour,
anime backgrounds, botanical plates. It is weak at photorealism and at acting faces. If a reference is photoreal,
say so before building and propose an illustrated take on it.

## Stage 1: Study every reference

The user may hand you many references, so give each one a job rather than averaging them into mush.

```bash
python3 $SKILL/scripts/study.py animations/<slug>/study <files or folders...>
```

This gives you, per reference, a contact sheet, a palette, and for videos the cuts and the pacing curve. If only part
of a video matters, add its range in seconds, as in `"reel.mp4@0-12"`, or talking-head footage skews the results.
Then look at the sheets yourself, and crop in where texture matters. Numbers can't tell you why something feels good.

Write `style.md`:

- **What each reference gives us**, one line each: texture from this one, type from that one, pacing from another.
- **What we will not copy**: poses, characters, logos, signatures, exact compositions. Take the style, not the work;
  the exception is a Repaint or Move job on an image the user asked to animate.
- **Palette** as hex values, **type** (`assets/fonts/` has two to start with, or copy in any open font), **texture**, **motion feel**.
- **One device** that ties the piece together: a lens, a ripple, a line that never breaks. Films without one feel
  like a slideshow.

Add a short card for each new reference to `animations/library.md`, so its lessons outlive this project. Reuse
cards when the user points at a style they've used before, and extend one only when you learned something new.

**Gate:** you can say in one sentence what this piece looks like and why that serves the topic.

## Stage 2: Beats

If there are facts in the piece, check them first. A wrong claim drawn beautifully is still wrong, and popular
"facts" are often loose. Note anything you softened for the final report.

Write `beats.md` as one table. Picture and sound are planned together because that sync is what makes it feel
expensive:

| Time | Picture | Sound |
| --- | --- | --- |
| 0-1.5 s | An orange drop falls and spreads | Drip, wet bloom, pad comes in |
| 1.5-3 s | Title line, details pop on | Pluck per word, tiny ticks |

**Gate:** something moves in the first half second; the shape is hook, build, a breath, payoff; no stretch over
2 seconds without a new picture idea; the end holds about 1.5 seconds so it can be read. Let the picture carry the
new ideas rather than the words: each caption needs about 1.5 seconds on screen, so cut captions before shortening
them. Keep text out of the top 12% and bottom 18% of a vertical frame.

## Stage 3: Build the picture

Copy `assets/piece-template.html` to `piece.html` and draw in it. The contract is `window.PIECE` plus
`window.renderFrame(t)`.

`renderFrame(t)` must depend only on `t`, and may be async. Stills jump straight to any time, so anything remembered
between frames, or any unseeded `Math.random()`, breaks them. Paint expensive static layers once inside `window.ready`,
from a seeded generator, then composite per frame.

To show another film inside a piece, extract its frames to `clips/` as numbered JPEGs, load the one you need with an
`Image` inside an async `renderFrame`, and draw it to the canvas.

Read `references/styles.md` before drawing; it has working recipes (cel clouds, foliage, walking figures, water,
watercolour, paper) and the source files to copy from. Depth comes from layers moving at different speeds, life
comes from small secondary motion: sway, drift, shimmer, flicker.

Review stills early and often, long before a full render:

```bash
python3 $SKILL/scripts/render.py animations/<slug>/piece.html --stills 0.5 3 7 12
```

Look at them at full size, compare them side by side with the references, and fix what's off. Expect several rounds.
The first still is usually a rough draft, and this loop is where the quality comes from.

```bash
python3 $SKILL/scripts/compare.py animations/<slug>/out/compare.jpg <stills and reference images...>
```

**Gate:** a still from the middle looks like it was made with the same materials as the references: same paper, paint,
line and colour. The subject can be new. Clip-art versions of the reference don't pass.

## Stage 4: Sound

Write `score.json` against the same times as `beats.md`. See the header of `scripts/synth.py` for the sounds
available: plucks, bells, pads, drips, ticks, swells, whooshes, impacts, kicks and noise beds.

```bash
python3 $SKILL/scripts/synth.py animations/<slug>/score.json animations/<slug>/out/score.wav
```

Stay in one key. Land the hits on picture events, not on a grid. Leave real quiet before the payoff, because the
contrast is what makes it land. Generate long runs of notes with a few lines of Python rather than typing them out.

You can't hear it, so read the level report `synth.py` prints: look for dips you didn't plan, and for the signature
sound being buried under the rest.

### If the piece is narrated

Narration comes before the picture, because word timings set every beat. Record it with whatever voice tool the user
has, transcribe it with word timings (faster-whisper works), then build the beats and captions from those times.
Whisper can start a word early in the silence before it, so check the waveform before cutting in a pause.

Mix the voice over the score, then render with the result as `--audio`. The score ducks under the voice, so music rises
in the pauses:

```bash
python3 $SKILL/scripts/mix.py animations/<slug>/out/voice.wav animations/<slug>/out/score.wav animations/<slug>/out/mix.wav
```

## Stage 5: Render, check, fix

```bash
python3 $SKILL/scripts/render.py animations/<slug>/piece.html --audio animations/<slug>/out/score.wav
python3 $SKILL/scripts/qc.py animations/<slug>/out/<slug>.mp4
```

`render.py` writes `out/<slug>.mp4`, mastered to -14 LUFS. It prints progress, and takes about 1-2 minutes for 15
seconds of a typical piece; run it in the background if a piece is heavy. After a sound-only change, add `--remux`
to swap the audio in seconds without redrawing.

`qc.py` flags dead stretches, one-frame glitches and loudness, and writes a contact sheet. It can't judge whether
motion looks good, so read the sheet too, then step through the risky moments frame by frame in close-up crops:
transitions, text on and off, where layers overlap, and a full cycle of any repeated motion. Fix and re-render until
clean.

## Hand over

Report in the user's plain language: what you made, how each reference was used, what you checked, and what you
could not check. You cannot hear the score or watch it at speed, so say so. Add:

- **One fact to know**, if you softened a claim.
- **Easy tweaks**: 3 or 4 specific changes they could ask for next.
- Whether a reference belongs to someone else and needs thought before commercial use.
Pliki w paczce (5)
  • .gitignore 1 KB
  • LICENSE 1 KB
  • README.md 3 KB
  • SKILL.md 9 KB
  • requirements.txt 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · JAYANTCH1797/animate-skill95MIT
hamedmp/matrix-os100AGPL-3.0
emilkowalski/skill100MIT
emilkowalski/skills100MIT
arcreel/arcreel100AGPL-3.0
growupanand/ConvoForm100Apache-2.0
mathews-tom/armory100MIT
owid/owid-grapher100MIT
d3uceY/SpriteWare100MIT

Migawka bazy z 13.11.2026 · wersja paczki 48230a83d485 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100animation-studio
    Tworzy animowane wideo z muzyką: krótkie kreskówki, filmy wyjaśniające z lektorem, filmy promocyjne, Reels, TikToki, lyric video, animowane mapy i infografiki.
  • 100video-by-reference
    Tworzy wideo generowane w kodzie, ucząc się stylu, montażu i tempa z filmu referencyjnego, z oryginalną ścieżką dźwiękową.
  • 90animated-video
    Tworzy animowane wideo w kodzie z Remotion: wyjaśnienia, opowieści postaci, grafiki ruchome i infografiki na podstawie lektora.
  • 100video-director
    Reżyseruje, buduje i weryfikuje krótkie filmy pisane kodem i renderowane klatka po klatce, od motion graphics po pętle.
  • 95motion
    Tworzy filmy motion graphics z kodu: zwiastuny, reklamy, animowane wyjaśnienia i sekwencje tytułowe, z dźwiękiem i pętlą samokrytyki.
  • 100story-animator
    Tworzy narracyjny film animowany 2D, w którym każda klatka jest rysowana kodem w Remotion, z lektorem ElevenLabs.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.