Que fait Animation de messages textuels ?
Transformez un script de conversation en une vidéo qui arrête le défilement : les bulles apparaissent une à une, un indicateur de saisie pulse avant chaque réponse, un son pop se déclenche à l'envoi, et le fil défile automatiquement pour garder le dernier message dans le cadre. C'est l'un des formats « sans visage » les plus engageants pour les réseaux sociaux — une histoire racontée en bulles iMessage/WhatsApp/SMS que le spectateur lit comme s'il regardait par-dessus l'épaule de quelqu'un.
Quand l'utiliser
- Vidéos « faux SMS » / histoires de chat pour TikTok, Reels et Shorts (9:16 vertical).
- Animation d'une conversation iMessage, WhatsApp ou SMS générique à partir d'un script.
- Vidéos de réponse/réaction où un fil dévoile une punchline message par message.
- Production en lot de nombreuses vidéos de chat à partir d'un template + un tableau de messages ou un CSV.
Deux règles intangibles
- Un message apparaît à la fois, sur un rythme. L'engagement vient du goutte-à-goutte : un temps de saisie, puis une bulle apparaît, puis une pause pour lire. Ne déversez jamais tout le fil à l'image 0 — rythmez-le comme une vraie conversation (un indicateur de saisie avant les réponses reçues, un court temps de lecture après chaque bulle).
- Le chrome doit être immédiatement reconnaissable comme l'application réelle. Envoyé = à droite, bleu (iMessage) ou vert (SMS) / vert WhatsApp ; reçu = à gauche, gris. Queue sur la dernière bulle d'une série, coins arrondis ~18–22 px, barre de statut et en-tête corrects. Si un spectateur ne peut pas dire de quelle application il s'agit dans la première demi-seconde, l'illusion est rompue.
Le modèle de données — le script d'abord, le rendu ensuite
Tout est basé sur un tableau de messages. Écrivez l'histoire comme des données ; le moteur de rendu se contente de la jouer. C'est ce qui rend le format industrialisable : un template × N scripts → N vidéos.
type Message = {
from: "me" | "them"; // me = envoyé (droite/bleu), them = reçu (gauche/gris)
text: string;
typingMs?: number; // affiche l'indicateur de saisie pendant cette durée avant la bulle (reçu uniquement)
delayMs?: number; // temps de lecture APRÈS la bulle précédente, avant celle-ci
status?: "delivered" | "read"; // accusé sous la dernière bulle envoyée
reaction?: "❤️" | "👍" | "😂" | "‼️" | "❓"; // tapback, arrive ~400 ms après la bulle
};
const thread: Message[] = [
{ from: "them", text: "attends t'es OÙ là maintenant", typingMs: 900 },
{ from: "me", text: "devant chez toi 🙂", delayMs: 600, status: "read" },
{ from: "them", text: "...", typingMs: 1400, reaction: "❓" },
];
Dérivez chaque timestamp d'image de ce tableau — voir « Timing » ci-dessous. Gardez text/from comme seuls champs obligatoires pour qu'un CSV (from,text,typingMs,delayMs,status) s'y mappe directement.
Disposition et alignement des bulles
Une bulle est une pilule de largeur maximale alignée sur son côté. Envoyé est collé à la bordure droite ; reçu est collé à la gauche. Empilez verticalement dans l'ordre d'envoi ; la dernière bulle d'une série consécutive du même expéditeur reçoit la queue.
const BUBBLE: React.CSSProperties = {
maxWidth: "74%", // jamais pleine largeur — laisse la marge « c'est un téléphone »
padding: "14px 18px",
borderRadius: 22,
fontSize: 34, // proportions iMessage à 1080 px de large
lineHeight: 1.25,
wordBreak: "break-word",
};
const SENT: React.CSSProperties = {
...BUBBLE, alignSelf: "flex-end", background: "#0A84FF", color: "#fff", // iMessage bleu
};
const RECEIVED: React.CSSProperties = {
...BUBBLE, alignSelf: "flex-start", background: "#3B3B3D", color: "#fff", // gris mode sombre
};
Aide-mémoire des palettes : iMessage envoyé #0A84FF (fond clair #1C1C1E), reçu #E9E9EB texte #000 (clair) / #3B3B3D (sombre). SMS envoyé vert #37C24A. WhatsApp envoyé #005C4B, reçu #202C33 sur fond de chat #0B141A, avec des coches (gris = envoyé, bleu #53BDEB = lu). Utilisez UNE application complètement ; ne mélangez pas le chrome iMessage avec les coches WhatsApp.
Apparition décalée + indicateur de saisie
Chaque bulle surgit légèrement depuis le bas avec un petit effet de zoom, ancrée à sa propre image d'entrée. Les messages reçus sont précédés d'une bulle de saisie à trois points qui pulse, puis est remplacée par la vraie bulle.
import { useCurrentFrame, useVideoConfig, spring, interpolate, Sequence } from "remotion";
const Bubble: React.FC<{ enterFrame: number; sent: boolean; children: React.ReactNode }> =
({ enterFrame, sent, children }) => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const p = spring({ frame: frame - enterFrame, fps, config: { damping: 14, mass: 0.7 } });
return (
<div style={{
alignSelf: sent ? "flex-end" : "flex-start",
transform: `translateY(${interpolate(p, [0, 1], [24, 0])}px) scale(${interpolate(p, [0, 1], [0.85, 1])})`,
opacity: interpolate(p, [0, 1], [0, 1]),
transformOrigin: sent ? "bottom right" : "bottom left",
}}>{children}</div>
);
};
// indicateur de saisie à trois points — les points respirent sur une sinusoïde, pilotée par l'image (pas de minuteurs CSS)
const Typing: React.FC = () => {
const frame = useCurrentFrame();
const dot = (i: number) => 0.4 + 0.6 * (0.5 + 0.5 * Math.sin((frame / 8) - i * 0.9));
return (
<div style={{ ...RECEIVED, display: "flex", gap: 8, padding: "18px 20px" }}>
{[0, 1, 2].map(i => (
<span key={i} style={{ width: 12, height: 12, borderRadius: 6, background: "#aaa", opacity: dot(i) }} />
))}
</div>
);
};
Placez l'indicateur de saisie dans un <Sequence from={typingStart} durationInFrames={typingLen}> juste avant le <Sequence> de la bulle pour qu'il s'affiche, puis soit remplacé par la vraie bulle. Seuls les messages reçus tapent ; les messages envoyés apparaissent simplement (vous ne vous regardez pas taper).
Timing — transformez le tableau en images
Parcourez les messages en accumulant un curseur en ms. C'est la source de vérité unique que les entrées spring, les fenêtres de saisie, les sons et le défilement automatique lisent tous.
const f = (ms: number) => Math.round((ms / 1000) * fps);
let cursor = 0;
const timeline = thread.map((m) => {
cursor += m.delayMs ?? 500; // temps de lecture avant ce message
const typingLen = m.from === "them" ? (m.typingMs ?? 800) : 0;
const typingStart = cursor;
cursor += typingLen; // la saisie se joue pendant le temps
const enterMs = cursor; // la bulle apparaît à la fin de la saisie
cursor += 250; // temps de stabilisation avant le prochain temps de lecture
return { ...m, typingStartMs: typingStart, typingLenMs: typingLen, enterMs };
});
const durationMs = cursor + 1000; // marge finale pour que la dernière bulle soit lisible
Réglez la sensation : les fils rapides/crépitants utilisent delayMs 300–500 et typingMs 500–900 ; les révélations pleines de suspense étirent typingMs jusqu'à 1500–2500 avant la ligne de chute. Calculez durationInFrames à partir de durationMs dans calculateMetadata pour qu'un script plus long produise automatiquement une vidéo plus longue.
Accusés de lecture, horodatages et réactions
- Accusé (« Delivered » / « Read ») s'affiche petit et aligné à droite sous la dernière bulle envoyée ; fondu entrant ~300 ms après l'arrivée de la bulle. Sur WhatsApp, c'est la double coche qui devient bleue.
- Horodatage (« Today 9:41 PM ») est un séparateur gris centré au-dessus du premier message d'un nouveau bloc horaire — ne l'affichez pas sur chaque bulle.
- Réaction / tapback s'agrandit dans le coin de sa bulle cible ~400 ms après l'apparition de la bulle, avec un léger dépassement. Ancrez-le au
enterMs + 400de cette bulle, pas à une image globale.
Défilement automatique — gardez la dernière bulle dans le cadre
Lorsque la pile dépasse la zone visible, déplacez tout le fil vers le haut pour que la dernière bulle se trouve dans le tiers inférieur. Animez le décalage de défilement vers la cible avec un spring à chaque fois qu'un message arrive — il doit glisser, pas sauter.
// targetY = hauteur totale des messages au-dessus du bas de la fenêtre, recalculée à chaque entrée de bulle
const scroll = spring({ frame: frame - lastEnterFrame, fps, config: { damping: 200 } });
const y = prevY + (targetY - prevY) * scroll; // transition douce de l'ancien décalage au nouveau
return <div style={{ transform: `translateY(${-y}px)` }}>{/* bulles */}</div>;
Gardez la bulle la plus récente éloignée de la zone de sécurité inférieure (voir ci-dessous) pour que les points d'accusé/saisie en dessous restent visibles.
Synchronisation sonore (pop par message)
Un « swoosh/pop » net à chaque envoi et un « ding » plus doux à chaque réception représentent la moitié de la sensation de réalisme de ce format. Placez un signal audio par message au enterMs de ce message, dans la même base de temps que les visuels.
import { Audio, staticFile, Sequence } from "remotion";
{timeline.map((m, i) => (
<Sequence key={i} from={f(m.enterMs)}>
<Audio src={staticFile(m.from === "me" ? "send.mp3" : "receive.mp3")} />
</Sequence>
))}
Ajoutez éventuellement un léger bruit de clavier en fond pendant chaque fenêtre de saisie. Gardez les signaux courts (<300 ms) pour qu'ils ne s'accumulent pas sur les fils rapides. Ne déclenchez jamais le son à partir d'un timer — planifiez-le sur la timeline des images pour qu'il survive au rendu headless.
Zone de sécurité pour le 9:16 (1080×1920)
| Zone | À garder libre | Pourquoi |
|---|---|---|
| Barre de statut haute | ~120 px | Votre fausse barre de statut/encoche se trouve ici ; ne mettez pas de bulles en dessous |
| En-tête de l'app | ~150 px (avatar + nom) | L'en-tête de contact vend l'application — gardez-le épinglé et dégagé |
| Barre de saisie + UI basse | ~360 px | La fausse barre de composition ET l'UI de légende/CTA/audio de la plateforme s'entassent toutes les deux en bas |
| Marges latérales | centre ~88 % de largeur | Les bulles ne touchent jamais le bord de l'écran — la marge est ce qui fait penser à « un téléphone » |
Faites défiler la conversation en direct dans la bande entre l'en-tête et la barre de composition. Faites atterrir chaque nouvelle bulle dans le tiers inférieur de cette bande (au-dessus de la zone de saisie), puis défilez automatiquement — c'est là que l'œil attend le nouveau message.
Liste de vérification pour la sortie
- Un seul tableau de messages pilote tout ; les horodatages sont dérivés, pas placés à la main.
- Un message à la fois : temps de lecture → saisie (reçu uniquement) → apparition, sur un rythme réglé.
- Chrome d'application correct de bout en bout (couleurs, queues, en-tête, accusés) — pas de mélange d'applications.
- Envoyé à droite/bleu-ou-vert, reçu à gauche/gris ; queue sur la dernière de chaque série.
- Accusé sous la dernière bulle envoyée ; séparateur d'horodatage par bloc temporel ; dépassement des tapbacks entrants.
- Défilement automatique maintient la bulle la plus récente dans le tiers inférieur, hors des zones de sécurité.
- Un pop/ding par message, planifié sur la timeline des images (pas de timers).
- En-tête épinglé sous la barre de statut ; conversation dans la bande de sécurité 9:16.
Livrez et vérifiez (images rendues → MP4)
Assistant empaqueté (
scripts/) : mosaïquez vos images avecscripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png, puis vérifiez l'encodage avecscripts/probe-mp4.sh out.mp4 [LxH] [fps]. Voirscripts/README.md.
Livré en tant que composition Remotion (<Composition> + schéma zod + defaultProps) dont les props sont le tableau de messages. Chaque entrée de bulle, pulsation de saisie, décalage de défilement et signal sonore est piloté par l'image via useCurrentFrame() — jamais Date.now() / Math.random() / de minuteurs d'animation CSS — pour que n'importe quelle image soit rendue de manière identique en mode headless. Livrable = out/*.mp4 + le projet (re-rendu avec un nouveau script). 9:16 vertical (1080×1920) est la valeur par défaut. La durée dépend des données, donc calculez durationInFrames dans calculateMetadata à partir du curseur de la timeline, jamais à la main.
Boucle de vérification — rendre des images → inspecter → encoder. Le timing des apparitions et la position de défilement sont ce qui casse ; vérifiez les images exactes avant de lancer un encodage.
# Images AVEC LES PROPS FOURNIES (le vrai fil) à : un temps de saisie / une apparition au milieu / la dernière bulle
npx remotion still TextThread out/f-typing.png --frame=24 --props='{"threadSrc":"thread.json"}'
npx remotion still TextThread out/f-mid.png --frame=90 --props='{"threadSrc":"thread.json"}'
npx remotion still TextThread out/f-end.png --frame=N --props='{"threadSrc":"thread.json"}' # N = durationInFrames-1
# Inspectez chaque PNG :
# - l'image 24 montre l'indicateur de saisie à trois points à GAUCHE (reçu), pas encore de vraie bulle
# - à l'image du milieu, la bulle qui vient d'arriver est du bon côté/couleur avec sa queue ; accusé/réaction bien placés
# - le fil a défilé automatiquement pour que la bulle la plus récente se trouve dans le tiers inférieur, PAS cachée sous la barre de composition
# - le chrome de l'application est cohérent (barre de statut, en-tête) et à l'intérieur de la bande de sécurité 9:16 ; rien sous l'encoche haute
npx remotion render TextThread out/thread.mp4 --props='{"threadSrc":"thread.json"}' # encodez une fois que les images sont bonnes
npx remotion render TextThread out/demo.gif --codec=gif # clip de preuve pour le README
Utilisez npx remotion compositions pour lire durationInFrames/fps et choisir les images de saisie/milieu/fin. Pour un aperçu rapide sans build, la même disposition s'affiche sous forme de page HTML autonome avec un mécanisme de recherche ?t=N — voir references/bubble-recipes.md.
Avant de terminer :
- Les images sont rendues proprement à une image de saisie, une apparition au milieu et la dernière bulle — pas de polices/audio manquants.
- Sur une image de saisie, l'indicateur (pas la bulle) s'affiche du côté reçu ; la bulle n'apparaît qu'après.
- Chaque bulle est du bon côté/couleur avec la bonne queue ; accusé/horodatage/réaction arrivent là où prévu.
- Le défilement automatique maintient la bulle la plus récente dans le tiers inférieur et dans la zone de sécurité 9:16 à chaque image vérifiée.
- Uniquement piloté par l'image (pas de
Date.now()/Math.random()/minuteurs) ; les props fournies s'affichent correctement ; MP4 + GIF optionnel émis.
Fichiers de référence
references/bubble-recipes.md— modèle prêt à l'emploi : chrome et palettes iMessage/WhatsApp/SMS, modèle de données message → timeline d'images, bulle spring + queue, indicateur de saisie à trois points, accusés de lecture/horodatages/tapbacks, défilement automatique, planification sonore par message, la composition Remotion complète aveccalculateMetadata, et un aperçu HTML autonome avec le mécanisme de recherche?t=N.references/data-driven.md— la forme des données script→messages, création de fils en JSON/CSV, cartographie d'un CSV dans le typeMessage[], et rendu en lot de nombreuses vidéos à partir d'un seul template avec@remotion/renderer.