Communitygithub.com

yt-film

Créez un documentaire ou une vidéo explicative YouTube narrée de longue durée avec le moteur Python yt-film. Utilisez-le pour des idées d'histoires, des recherches de sources, des guides d'images, des scripts, une narration chronométrée, de la musique, des images animées, des cartes, des pages de bande dessinée, des notes de bas de page de sources, du son, des rendus par lots de paysages, des mixages finaux, des doublages, des miniatures, la configuration ou l'exemple Chadwick.

Qu'est-ce que yt-film ?

yt-film est une compétence d'agent IA conçue pour produire des films narrés de longue durée à partir d'images fixes, principalement destinés à YouTube ou d'autres plateformes vidéo. Elle transforme un guide d'images et un script générés par l'utilisateur et Claude en un documentaire complet, en utilisant un moteur Python (OpenCV, Pillow, NumPy, SciPy) pour animer les images, synchroniser la voix et la musique, et créer des effets visuels comme des scènes animées et des pages de bande dessinée. La compétence prend en charge plusieurs formats de narration (histoire, explicatif, compte à rebours, etc.) et des styles visuels (gouache, propre, noir, etc.), tous configurables via des fichiers de configuration. Le flux de travail couvre la recherche, la rédaction du script, la génération vocale (Gemini TTS ou voix personnalisée), la musique (Lyria Gemini ou pistes personnalisées), les listes de plans, le rendu par lots, le montage final et le doublage. Elle est conçue pour être exécutée sur macOS, Linux et Windows, et nécessite l'approbation de l'utilisateur avant tout rendu. Un exemple de référence, 'Chadwick', illustre toutes les techniques avec une courte vidéo d'effets.

Compatible avec✓Claude Code✓Codex CLI~Cursor✓Gemini CLI
npx skills add https://github.com/ma7pc27/yt-film/tree/HEAD

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

yt-film : films narrés à partir d'images fixes

Pour les Reels verticaux, les Shorts ou les vidéos sociales sérialisées, utilisez la compétence complémentaire yt-film-reels.

L'ensemble de base est un point de départ, pas le film. Pour chaque film, paysage ou portrait, effectuez la passe créative dans Claude est le conducteur avant les listes de plans : décidez de ce dont cette histoire a besoin que la base n'a pas (ses propres effets, transitions, sons, dispositifs de dessin), créez-les ou cherchez-les, et ne réutilisez un effet de base que là où il convient. Le moteur rend aussi le portrait : mode portrait.

Une chaîne de production pour les films narratifs : l'utilisateur crée environ 150 images fixes à partir d'un guide que Claude écrit, Claude écrit le script à partir de ces images, une voix le lit, et le moteur Python donne vie à chaque image en rythme avec les mots. Le film de référence est l'exemple Chadwick (examples/chadwick/, La fille de Carnegie : la femme qui a emprunté des millions en tant que fille secrète d'Andrew Carnegie) : ses images, script, voix, partition, listes de plans et la vidéo de test d'effets de 70 secondes (examples/chadwick/video/chadwick_effects_test.mp4) montrent chaque technique.

REPO ci-dessous est le dossier de cette compétence (où se trouve ce fichier). PY est son Python : REPO/.venv/bin/python sur macOS/Linux, REPO\.venv\Scripts\python.exe sur Windows. Exécutez toujours les commandes du moteur avec PY, depuis le dossier tools/ du projet. Si .venv n'existe pas, configurez d'abord : suivez le Runbook d'installation (pour Claude) dans references/install.md étape par étape (demandez avant les installations à l'échelle du système ; l'utilisateur colle sa propre clé API).

Règles de base

  • Ne jamais rendre sans l'accord de l'utilisateur. Vérifiez avec stills.py (une planche contact en ~30 s). Les rendus par lots, les aperçus, la fin et l'assemblage final prennent des minutes à heures : dites ce que vous rendrez et combien de temps cela peut prendre, et attendez un oui. Ne rendez pas à nouveau ce qui est déjà rendu, sauf si cela a changé et que l'utilisateur le souhaite.
  • Demandez les choix de l'utilisateur une fois par projet : quel outil d'image (references/image-generation.md), voix (Gemini TTS ou la sienne : references/voice.md), musique (Lyria ou la sienne : references/music.md), sa niche et le nom de sa chaîne, et les trois choix qui rendent la chaîne sienne : le style d'image (l'ouverture : gouache, éditorial plat, noir, craie, bande dessinée, livre d'histoires, plan bleu, ou le sien ; personnages ou pas), le look du moteur (YTF_LOOK : gouache, propre, noir, craie, bande dessinée, livre d'histoires, plan bleu ; look.json pour les valeurs uniques) et le format (histoire, explicatif, compte à rebours, montée-chute, heure du conte, enfants, résumé, étude de cas, actualités) : references/art-styles.md, references/formats.md. Ne prenez pas par défaut le style pastel réaliste de l'exemple ; si l'utilisateur n'a pas de préférence, montrez les options dans un court tableau et recommandez-en une qui correspond à sa niche.
  • La niche de l'utilisateur est la sienne : ne l'orientez pas vers l'histoire ou le sujet de l'exemple. L'exemple est une référence pour les techniques, pas un modèle pour les sujets.
  • Windows : les chemins avec des barres obliques fonctionnent ; les longs travaux s'exécutent en arrière-plan ; les paramètres de vitesse dans references/performance.md. Ne supposez jamais d'outils macOS uniquement.
  • Pas de clés API dans les fichiers autres que .env. Téléchargez de vraies photos ou fichiers sonores seulement après l'accord de l'utilisateur (indiquez le fichier, la source, la taille et la licence).

La pile

TâcheOutilOù
Rechercherecherche web, liste de faits vérifiés avec sources ; signalez ce qui ne peut être confirméOUTLINE.md
Imagesl'outil d'image de l'utilisateur, à partir du guide de ClaudeIMAGE_GUIDE.md (+ IMAGE_PROMPTS.jsonl pour l'API), incoming/
ScriptClaude, écrit à partir du guide d'images, un passage ## par battement, notes [SHOTS: …]SCRIPT.md
VoixGemini TTS (voix Orus, lue lentement → 1,25x, pauses limitées) ou l'audio de l'utilisateur via import_voice.pytools/voice.py, tools/import_voice.py
Chronométrage des motsWhisper : mlx-whisper (Apple Silicon) ou faster-whisper (Windows/Intel/Linux)voice/<batch>_words.json
MusiqueLyria (API Gemini), un signal par section, ou les pistes sous licence de l'utilisateurtools/music.py → audio/music/
Moteur de filmPython (OpenCV, Pillow, NumPy, SciPy), pas d'After Effectstools/film.py, fx2.py, seq.py, signature.py, wr.py, kit.py
Listes de plansun fichier par lot sur seq.py, indexé sur les temps des mots du lottools/<histoire>.py + tools/shots_bN.py
Rendusparallèles, adaptés à la machine, basse prioritétools/render_all.py
Finla propre signature animée de l'utilisateur (exemple : cta.py)renders/cta.mp4
Assemblage finallots + fin, une partition continue, −14 LUFS / −2 dBTPtools/final.py
Doublagesespagnol + français par défaut : traduction Gemini + TTS en morceaux de ~3 min, adaptés aux créneaux anglaistools/dub.py
Miniaturesl'outil d'image de l'utilisateur, à partir d'un guidereferences/thumbnails.md

Les projets résident dans YTF_WORKSPACE (par défaut ~/yt-film-projects/<histoire>/), créé par PY REPO/scripts/new_project.py <histoire>, qui copie le moteur dans tools/ et crée chaque dossier. Les paramètres sont dans .env (projet d'abord, puis REPO) : GEMINI_API_KEY, YTF_CHANNEL, noms de voix/modèle, boutons de vitesse (.env.example les liste tous). engine/ytf.py trouve les polices, la clé, Whisper et l'art partagé sur tout OS.

L'ordre de travail

  1. Choisissez l'histoire si non donnée : 3 à 5 candidats avec vérifications des écarts (references/story-finding.md). Démarrez le projet avec son format et son look : PY REPO/scripts/new_project.py <nom> --format <format> --look <look> (écrit le modèle de structure du format dans OUTLINE.md, YTF_FORMAT et YTF_LOOK dans .env). Testez un nouveau style sur deux images avec stills.py avant d'écrire le guide complet (references/art-styles.md, dernière section).
  2. Histoire et faits : recherchez ; OUTLINE.md avec sources. Marquez tout ce qui n'est pas confirmé et contournez-le plus tard (« selon des rapports »), ne l'affirmez jamais comme un fait. Décidez de l'accroche (references/hooks.md : jamais du même type que les trois derniers films de l'utilisateur). Écrivez ensuite la colonne vertébrale en haut de OUTLINE.md (references/storytelling.md) : une question à laquelle le film répond et 8 à 12 battements reliés par « donc » / « mais » ; le premier acte erroné ou moment décisif vers ~15 % du film ; un ou deux passages de contexte par personne principale. Montrez-le à l'utilisateur avant le guide d'images.
  3. Guide d'images d'abord (references/image-guide.md, écrit pour la voie de l'utilisateur). Il suit la colonne vertébrale et la façon dont le film est raconté (montrez, puis dessinez : chaque ligne du battement nomme la ligne qu'elle sert et ce qui est dessiné dessus ou après). Visez ~150 images : carte de style, fiches de distribution, ~100 plans de scène avec couverture (W large, M moyen, F gros plan de visage en tant que EDIT, D détail, P point de vue), 6 scènes avec versions _lines, 12 feuilles de croquis + _lines, ~10 objets d'histoire vierges (« bases » : un carnet, une vieille carte, une carte, un grand livre, une enveloppe, un télégramme, un journal). Noms de fichiers et dossiers exacts. Règles de cohérence : references/consistency.md.
  4. Vérifiez les images au fur et à mesure de l'arrivée des groupes (mains, visages, détails d'époque, pas de texte, forme : les images arrivent ~16:9 et sont recadrées au centre en 2:1, donc rien d'important tout en haut/en bas). Téléchargements manuels : scripts/sort_images.py. Ensuite, les feuilles quadrillées en px du moteur (COLS=4 PY tools/egrid.py out.png IMG ...) et cartographiez les cheminées, lampes, bougies, souffle et zones calmes de chaque image avant d'écrire les plans.
  5. Script à partir des images. Chaque image générée est utilisée ; associez chaque passage à ses plans et effectuez la vérification des images inutilisées (exemple : examples/chadwick/tools/script_check.py), puis PY tools/story_check.py (dates prononcées, ouvertures de changement de scène, où tombe le passage [DRIVE], chaque jointure de lot) et les vérifications dans references/storytelling.md (raconter à nouveau, 15 %, mais/donc, pas d'explications empilées, 5–7 dates prononcées, montrer → dessiner). Pas de limite de longueur : racontez l'histoire complètement et sans hâte (~150 mots par minute ; Chadwick : 1 780 mots → 12 min). Terminez par la ligne d'appel à l'action de l'utilisateur.
  6. Voix : Gemini (voice.py --test d'abord, puis lots ; --pace et SPEEDS pour que chaque lot se situe à ~140–160 mots par minute) ou l'audio de l'utilisateur (import_voice.py --full | --passages | --batches). Définissez BATCHES (4–7 passages, ~65–100 s chacun, coupés au milieu de l'acte là où l'histoire avance ; seulement 2–3 coupures sur les ruptures d'acte ; rien de réintroduit au début d'un lot) et GAPS. Imprimez les mots de chaque lot avant d'écrire ses plans (Whisper entend mal les noms et écrit les nombres en chiffres : indexez sur ce qu'il a écrit).
  7. Musique : 5–7 signaux (music.py, ou les fichiers de l'utilisateur dans audio/music/) ; associez les signaux aux lots dans MUSIC de final.py.
  8. Listes de plans par lot avec seq.py (references/engine.md, examples/chadwick/tools/) : un module de film (<histoire>.py, comme chad.py) contient la table LIVE (les couches vivantes de chaque image) et les paramètres de carte ; chaque shots_bN.py fait ~60 lignes de S.at(time, scene(...)/page(...)/drawin(...)/map_shot(...)). Vérifiez chacun avec PY tools/stills.py bN et regardez la feuille avant de rendre quoi que ce soit.
  9. Rendus (avec l'accord de l'utilisateur) : PY tools/render_all.py exécute tous les lots en parallèle, autant à la fois que la mémoire libre de la machine le permet (environ 1,5 Go par rendu ; plus à la fois est plus lent une fois la mémoire épuisée) ; après les corrections, render_all.py b3 b7 ou --changed. Lancez-le dans sa propre fenêtre pour que la fermeture de Claude ne l'arrête pas, et suivez references/performance.md lorsqu'un rendu est lent ou que l'ordinateur lag (Windows surtout). Testez d'abord une nouvelle transition ou un nouvel effet sur deux images (un crash tardif gâche le rendu).
  10. Fin une fois par chaîne (references/cta.md), puis assemblage final PY tools/final.py ; vérifiez la durée, les images par seconde, le volume sonore sur le MP4 (−14 LUFS, pic ≤ −1,5 dB) et les images d'échantillon (references/final-render.md).
  11. Doublages (references/dubs.md) et miniatures (references/thumbnails.md) si souhaité.

Le look (la valeur par défaut de l'exemple ; chaque chaîne choisit le sien)

  • L'exemple : personnages à tête d'œuf (tête d'œuf, deux yeux ovales foncés, bouche d'un seul trait, pas de nez/oreilles/sourcils, mains arrondies simples) dans un monde réel fidèle à l'époque ; trait d'encre + gouache pastel mate ; look du moteur gouache. Les autres chaînes choisissent leur propre style d'image, leurs personnages (ou pas) et le look du moteur (references/art-styles.md) ; les règles ci-dessous s'appliquent à tous les styles.
  • Le look du moteur définit les couches ajoutées : teinte, grain, vignette, encre, papier d'étiquette, accent, polices, son de dessin (engine/look.py : YTF_LOOK, look.json). Ne codez jamais en dur une couleur ou une police dans un fichier de plans quand le look en a une (look.rgb("accent"), look.L.type_font) ; le look d'une chaîne doit changer en un seul endroit.
  • Pas de 2.5D, pas de découpes, pas de vidéo IA. Des images uniques avec des mouvements de caméra progressifs (zooms avant, panoramiques, dérive lente).
  • Ne gardez jamais une image trop longtemps : passez au plan suivant du moment (W→M→F→D→P) ou à une page dessinée.
  • Les explications par croquis sont de vrais dessins, pas des icônes : extraits du line art des feuilles ou dessinés par le moteur là où le code le fait bien (cartes précises, itinéraires, marques, figures simples).
  • Les bases vierges sont dessinées en direct dans leur propre médium : graphite sur papier, craie sur un tableau, encre au pinceau, photos en demi-teinte s'imprimant dans un journal, itinéraires à l'encre sur une carte.
  • Les lignes portent du sens : marques de pointage pour les années, anneaux sonores, chemins de feuilles qui tombent, lignes de fumée, figures barrées.
  • Les étiquettes (dates, lieux, noms) sont du texte tapé au niveau dans la police de caractères du look (machine à écrire dans gouache), tapé une touche à la fois avec un clic doux.
  • L'écriture sur un objet se trouve sur les lignes réelles de cet objet à leur angle ; l'impression illisible en dessous est d'abord effacée (fx2.clean_text).
  • Contraste toujours : rien de foncé sur foncé. Les étiquettes choisissent automatiquement le crème/encre avec un halo. Ne forcez jamais color="ink" sans vérifier ce qui se trouve en dessous.
  • Le sprite de l'outil est petit (échelle 0,28) pour ne jamais attirer l'attention.

Animation signature (tout en code sur les images fixes)

engine/signature.py, engine/fx2.py, aides de plan engine/wr.py, engine/seq.py. Une image fixe de chacune dans examples/chadwick/look/ ; chacune en mouvement dans la vidéo de test d'effets.

  • Images animées (l'image ne bouge jamais ; les couches vivent dessus) : fumée de particules de chaque cheminée, souffle dans le froid, flammes vivantes et la lumière qu'elles projettent, les propres lampes de l'image trouvées et respirant (fx2.lamps), neige, pluie, feuilles qui tombent, reflets. Pas de distorsion de pixels (sg.Flow) sur la fumée, la vapeur, le feu ou l'eau : cela brouille la peinture (look/flow_smear_avoid.png).
  • Visages qui agissent, seulement là où cela compte : pas de clignement ou d'expressions automatiques. Un visage agit seulement quand un plan passe act= / talk=, et seulement un visage avec une paire d'yeux assortie (sg.face_audit([...], out.jpg) : agir seulement là où les deux yeux sont entourés de vert). Indices : blinks, glances, widen, mouth_fx, expr (sourire, sourire éclatant, froncement, o, rire, yeux fermés, plisser...), talk=(ta, tb), marques de réaction (sweat, shake, !, ?, zzz). Une poignée de vrais battements par lot, jamais de décoration.
  • Pages de bande dessinée sur le tableau vierge (sg.Comic) : les bordures s'encrent elles-mêmes, chaque case s'encré puis se peint, la caméra visite les cases et plonge dans la dernière. Deux par film (l'accroche, le premier grand morceau d'action). Chaque case dure ≥ 1,8 s.
  • Dessins faits en direct (fx2.Draw) : une feuille de dessin s'encré dans son ordre de trait (sprite de stylo et son), puis ses lavis de couleur s'appliquent ; card=True pose d'abord un lavis crème doux sur les images chargées. Une feuille n'est jamais montrée comme une page de quatre : chaque dessin apparaît quand le narrateur le nomme, relié par des flèches et de courtes étiquettes tapées.
  • La carte explicative (une base réutilisée) : noms tapés et barrés, un mécanisme en chaîne de dessins avec flèches, trois dessins avec trois mots.
  • Vocabulaire de marque, choisi par sens, jamais la même marque à chaque fois : soulignement, coche, croix, crochet, lignes de mouvement, anneaux sonores, itinéraire (chemin pointillé + flèche), leader (point, ligne, étiquette tapée), pointage ; sg.Stamp (coup de tampon encreur : FORGÉ, FERMÉ, 14 ANS), sg.Tag (étiquette en papier déchiré), sg.Inset, `sg

…

[le contenu a été tronqué pour la traduction]

Skills associés