:clapper:
Vídeo Remotion
Remotion é um framework para criar vídeos programaticamente usando React. Em vez de editores baseados em linha do tempo, você escreve composições como componentes React onde cada quadro é uma função do número do quadro atual. Isso oferece todo o poder do TypeScript, pacotes npm e arquitetura baseada em componentes para criar vídeos - desde explicadores animados e clipes para redes sociais até visualizações baseadas em dados e vídeos personalizados em escala.
Esta skill cobre configuração de projeto, estrutura de composição, animações baseadas em quadros com interpolate e spring, sequenciamento de cenas, gerenciamento de ativos, integração de áudio, vídeos parametrizados com esquemas Zod e renderização para MP4/WebM via CLI ou APIs programáticas.
Quando usar esta skill
Ative esta skill quando o usuário:
- Quer criar um vídeo programaticamente usando React/TypeScript
- Pergunta sobre composições Remotion, useCurrentFrame ou useVideoConfig
- Precisa animar texto, elementos ou transições entre cenas
- Quer renderizar um vídeo para MP4, WebM ou GIF a partir de código
- Pergunta sobre animações spring, interpolate ou temporização baseada em quadros
- Precisa configurar um novo projeto Remotion do zero
- Quer adicionar áudio, imagens ou fontes a um vídeo Remotion
- Pergunta sobre geração de vídeos parametrizados / baseados em dados
- Precisa configurar o Remotion Studio para visualizar composições
NÃO ative esta skill para:
- Perguntas gerais sobre React não relacionadas à criação de vídeos - use skills de React
- Edição de vídeo com ferramentas tradicionais de linha do tempo (Premiere, DaVinci, FFmpeg CLI)
- Animações CSS para páginas web - use skills de animação / motion design
- Reprodução ou streaming de vídeo em aplicações web - use skills de player de mídia
Princípios-chave
-
Cada quadro é uma função pura - Um componente Remotion recebe o quadro atual via
useCurrentFrame()e deve renderizar deterministicamente para aquele quadro. Sem efeitos colaterais, sem aleatoriedade sem sementes, sem dependência do tempo real. O mesmo número de quadro deve sempre produzir a mesma saída visual. -
Composições são a unidade do vídeo - Cada
<Composition>define um vídeo com dimensões explícitas (largura, altura), taxa de quadros (fps) e duração (durationInFrames). Pense nas composições como "páginas" do seu projeto - uma por variante de vídeo ou cena que pode ser renderizada independentemente. -
Interpolate para tudo - A função
interpolate()mapeia números de quadro para qualquer valor numérico (opacidade, posição, escala, canais de cor). Combinada comextrapolateRight: 'clamp', é o carro-chefe para todas as animações. Usespring()quando precisar de easing baseado em física. -
Sequence para deslocamentos de tempo - Use
<Sequence from={frame}>para atrasar quando os filhos começam a aparecer, e<Series>para reproduzir filhos um após o outro. Nunca use setTimeout ou matemática manual de quadros para sequenciamento - as primitivas declarativas lidam com isso corretamente tanto na visualização quanto na renderização. -
Ativos são estáticos, dados são dinâmicos - Coloque imagens, fontes e arquivos de áudio na pasta
public/e referencie-os comstaticFile(). Para dados dinâmicos (respostas de API, registros de banco de dados), usedelayRender()/continueRender()para pausar a renderização até que os dados sejam carregados.
Conceitos principais
Estrutura de composição
Todo projeto Remotion tem um arquivo raiz que registra as composições:
import { Composition } from 'remotion';
import { MyVideo } from './MyVideo';
export const RemotionRoot: React.FC = () => {
return (
<Composition
id="MyVideo"
component={MyVideo}
durationInFrames={150}
fps={30}
width={1920}
height={1080}
/>
);
};
Temporização baseada em quadros
Toda temporização no Remotion é expressa em quadros, não em segundos. Para converter:
- Segundos para quadros:
segundos * fps - Quadros para segundos:
quadros / fps
A 30 fps, um vídeo de 5 segundos tem 150 quadros. O quadro 0 é o primeiro quadro.
Modelo de animação
Remotion fornece duas primitivas principais de animação:
| Primitiva | Caso de uso | Exemplo |
|---|---|---|
interpolate() | Mapeamento linear/clamped de quadro para valor | Fade, slide, escala |
spring() | Animação baseada em física com amortecimento/massa | Entradas saltitantes, movimento natural |
Ambas retornam um número que você aplica aos estilos (opacidade, transform, etc.).
Tarefas comuns
1. Configurar um novo projeto Remotion
npx create-video@latest
Isso cria um projeto com TypeScript, uma composição de exemplo e o Remotion Studio configurado. A estrutura do projeto será:
meu-video/
src/
Root.tsx # Registra todas as composições
MeuComp.tsx # Seu primeiro componente de composição
public/ # Ativos estáticos (imagens, fontes, áudio)
remotion.config.ts # Configuração do Remotion
package.json
Inicie o estúdio de visualização com:
npx remotion studio
2. Criar uma composição básica com useCurrentFrame
import { AbsoluteFill, useCurrentFrame, useVideoConfig, interpolate } from 'remotion';
export const TextoFadeIn: React.FC = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const opacidade = interpolate(frame, [0, 30], [0, 1], {
extrapolateRight: 'clamp',
});
const deslocamentoY = interpolate(frame, [0, 30], [20, 0], {
extrapolateRight: 'clamp',
});
return (
<AbsoluteFill
style={{
justifyContent: 'center',
alignItems: 'center',
backgroundColor: '#0f0f0f',
}}
>
<h1
style={{
fontSize: 80,
color: 'white',
opacity: opacidade,
transform: `translateY(${deslocamentoY}px)`,
}}
>
Olá Remotion
</h1>
</AbsoluteFill>
);
};
3. Animar texto palavra por palavra
Divida o texto em palavras e escalone a aparição de cada palavra usando <Sequence>:
import { AbsoluteFill, Sequence, useCurrentFrame, interpolate } from 'remotion';
const PalavraAnimada: React.FC<{ children: string }> = ({ children }) => {
const frame = useCurrentFrame();
const opacidade = interpolate(frame, [0, 15], [0, 1], {
extrapolateRight: 'clamp',
});
const deslocamentoY = interpolate(frame, [0, 15], [10, 0], {
extrapolateRight: 'clamp',
});
return (
<span
style={{
display: 'inline-block',
opacity: opacidade,
transform: `translateY(${deslocamentoY}px)`,
marginRight: 12,
}}
>
{children}
</span>
);
};
export const PalavraPorPalavra: React.FC<{ text: string }> = ({ text }) => {
const palavras = text.split(' ');
return (
<AbsoluteFill
style={{
justifyContent: 'center',
alignItems: 'center',
backgroundColor: '#1a1a2e',
flexWrap: 'wrap',
padding: 100,
}}
>
{palavras.map((palavra, i) => (
<Sequence key={i} from={i * 8}>
<PalavraAnimada>{palavra}</PalavraAnimada>
</Sequence>
))}
</AbsoluteFill>
);
};
4. Animações de elemento com spring
Use spring() para animações baseadas em física que parecem naturais:
import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring } from 'remotion';
export const CartaoSpring: React.FC = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const escala = spring({
frame,
fps,
config: { damping: 200, stiffness: 100, mass: 0.5 },
});
const deslizarParaCima = spring({
frame: frame - 10,
fps,
config: { damping: 12, stiffness: 100 },
});
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center', backgroundColor: '#0d1117' }}>
<div
style={{
width: 400,
height: 250,
backgroundColor: '#161b22',
borderRadius: 16,
transform: `scale(${escala}) translateY(${(1 - deslizarParaCima) * 50}px)`,
}}
>
<p style={{ color: 'white', fontSize: 32 }}>Animação Spring</p>
</div>
</AbsoluteFill>
);
};
5. Transições de cena com Sequence e Series
Use <Sequence> para cenas sobrepostas e <Series> para reprodução sequencial:
import { AbsoluteFill, Sequence, Series, useCurrentFrame, interpolate } from 'remotion';
const Cena: React.FC<{ color: string; title: string }> = ({ color, title }) => {
const frame = useCurrentFrame();
const opacidade = interpolate(frame, [0, 20], [0, 1], {
extrapolateRight: 'clamp',
});
return (
<AbsoluteFill style={{ backgroundColor: color, justifyContent: 'center', alignItems: 'center' }}>
<h1 style={{ color: 'white', fontSize: 72, opacity: opacidade }}>{title}</h1>
</AbsoluteFill>
);
};
export const MultiCena: React.FC = () => {
return (
<AbsoluteFill>
<Series>
<Series.Sequence durationInFrames={60}>
<Cena color="#e63946" title="Cena Um" />
</Series.Sequence>
<Series.Sequence durationInFrames={60}>
<Cena color="#457b9d" title="Cena Dois" />
</Series.Sequence>
<Series.Sequence durationInFrames={60}>
<Cena color="#2a9d8f" title="Cena Três" />
</Series.Sequence>
</Series>
</AbsoluteFill>
);
};
6. Manipulação de ativos (imagens, fontes, staticFile)
Referencie ativos estáticos da pasta public/ usando staticFile():
import { AbsoluteFill, Img, staticFile } from 'remotion';
export const DemonstracaoAtivo: React.FC = () => {
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center' }}>
<Img
src={staticFile('logo.png')}
style={{ width: 300, height: 300 }}
/>
</AbsoluteFill>
);
};
Carregue fontes personalizadas com @remotion/google-fonts ou CSS @font-face:
import { loadFont } from '@remotion/google-fonts/Inter';
const { fontFamily } = loadFont();
export const DemonstracaoFonte: React.FC = () => {
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center' }}>
<h1 style={{ fontFamily, fontSize: 64, color: 'white' }}>
Fonte Personalizada
</h1>
</AbsoluteFill>
);
};
7. Integração de áudio
Adicione áudio com controle de volume e temporização:
import { AbsoluteFill, Audio, Sequence, staticFile, interpolate } from 'remotion';
export const ComAudio: React.FC = () => {
return (
<AbsoluteFill style={{ backgroundColor: '#000' }}>
<Audio
src={staticFile('musica-de-fundo.mp3')}
volume={(f) =>
interpolate(f, [0, 30, 120, 150], [0, 0.8, 0.8, 0], {
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp',
})
}
/>
<Sequence from={15}>
<Audio src={staticFile('whoosh.mp3')} volume={0.5} />
</Sequence>
</AbsoluteFill>
);
};
8. Renderização de vídeos
Renderize para MP4 a partir da linha de comando:
# Renderizar composição padrão
npx remotion render src/index.ts MeuVideo out/video.mp4
# Renderizar em resolução 4K
npx remotion render src/index.ts MeuVideo out/video.mp4 --width 3840 --height 2160
# Renderizar para WebM
npx remotion render src/index.ts MeuVideo out/video.webm --codec vp8
# Renderizar um intervalo específico de quadros
npx remotion render src/index.ts MeuVideo out/video.mp4 --frames 0-90
# Renderizar com props personalizadas
npx remotion render src/index.ts MeuVideo out/video.mp4 --props '{"title": "Olá"}'
Para renderização programática, consulte references/rendering-guide.md.
Anti-padrões / erros comuns
| Erro | Por que está errado | O que fazer em vez disso |
|---|---|---|
Usar Math.random() sem uma semente | Produz saída diferente por quadro durante a renderização | Use uma semente determinística ou random() do Remotion |
Usar setTimeout / setInterval | Quebra a renderização baseada em quadros - temporizadores não avançam por quadro | Use useCurrentFrame() e matemática de quadros para toda a temporização |
Faltando extrapolateRight: 'clamp' | Valores ultrapassam o intervalo alvo em quadros posteriores | Sempre adicione { extrapolateRight: 'clamp' } ao interpolate() |
| Codificar fps nos cálculos de quadros | Quebra quando o fps da composição muda | Use useVideoConfig().fps para derivar a temporização |
Usar <Video> para saída renderizada | Desempenho de renderização mais lento devido à sobrecarga de busca | Use <OffthreadVideo> para melhor desempenho de renderização |
Esquecer delayRender() para dados assíncronos | Renderiza antes do carregamento dos dados, mostrando quadros vazios/quebrados | Chame delayRender() imediatamente, continueRender() quando pronto |
| Estilos inline com valores não determinísticos | Cintilações ou inconsistência entre visualização e renderização | Derive todos os valores de estilo apenas do número do quadro |
| Composição única gigante | Difícil de manter e impossível renderizar cenas independentemente | Divida em múltiplas composições ou use Series para cenas |
Armadilhas
-
O padrão extrapolateRight é 'extend' - Se você escrever
interpolate(frame, [0, 30], [0, 1])sem clamp, o valor continuará aumentando além de 1 após o quadro 30 (por exemplo, o quadro 60 dá opacidade 2). Sempre passe{ extrapolateRight: 'clamp' }a menos que você queira intencionalmente a extrapolação. -
spring() começa do quadro 0 do seu contexto - Ao usar
spring()dentro de um<Sequence from={60}>, o quadro passado para spring reinicia para 0 no quadro 60 do pai. Se você passar o quadro bruto do pai, a animação já estará completa. UseuseCurrentFrame()dentro do filho do Sequence, não um quadro do pai. -
Os caminhos de staticFile() são relativos a public/ - Chamar
staticFile('images/logo.png')procura porpublic/images/logo.png. Usar caminhos absolutos ou caminhos fora depublic/falhará silenciosamente na visualização e gerará erro durante a renderização. Certifique-se de que todos os ativos estejam no diretóriopublic/. -
delayRender tem um tempo limite de 30 segundos - Se sua operação assíncrona (chamada de API, carregamento de fonte) demorar mais de 30 segundos, a renderização será abortada. Aumente o tempo limite com
delayRender('Carregando dados', { timeoutInMilliseconds: 60000 })para operações lentas. -
As dimensões da composição devem ser números pares - Codecs de vídeo (H.264, VP8) exigem largura e altura pares. O Remotion lançará um erro se você tentar renderizar uma composição com dimensões ímpares. Sempre garanta que a largura e a altura sejam números pares.
-
Mudanças de código durante a renderização não são refletidas - O Remotion compila seu código antes da renderização. Se você modificar arquivos de origem enquanto um vídeo está sendo renderizado, as alterações não serão incluídas até que você reinicie o processo de renderização. Sempre pare e reinicie a renderização após alterações no código.
Plataformas compatíveis
- Remotion Studio - Ambiente de desenvolvimento integrado para visualização e iteração de composições
- Linha de comando - Renderização via
npx remotion render - Renderização programática - API Node para integração em pipelines
- Lambda - Renderização em escala com AWS Lambda (pacote
@remotion/lambda)
Tópicos avançados
Vídeos Parametrizados
Use um esquema Zod para definir props que podem ser passadas ao renderizar:
import { z } from 'zod';
import { Composition } from 'remotion';
export const meuEsquema = z.object({
titulo: z.string(),
cor: z.string(),
});
// No Root.tsx:
<Composition
id="VideoParametrizado"
component={ParamVideo}
durationInFrames={150}
fps={30}
width={1920}
height={1080}
schema={meuEsquema}
defaultProps={{
titulo: 'Olá',
cor: '#ff0000',
}}
/>
Dados Assíncronos
Use delayRender e continueRender para dados baseados em API:
import { AbsoluteFill, useCurrentFrame, delayRender, continueRender, interpolate, staticFile, Img, Audio, Sequence, Series, spring, loadFont, Composition } from 'remotion';
import { useEffect, useState } from 'react';
export const VideoAssincrono: React.FC = () => {
const [dados, setDados] = useState(null);
const [handle] = useState(() => delayRender());
useEffect(() => {
fetch('https://api.exemplo.com/dados')
.then((res) => res.json())
.then((dados) => {
setDados(dados);
continueRender(handle);
});
}, [handle]);
if (!dados) return null;
// Renderizar usando os dados
return (
<AbsoluteFill style={{ backgroundColor: '#000', justifyContent: 'center', alignItems: 'center' }}>
<h1 style={{ color: 'white' }}>{dados.titulo}</h1>
</AbsoluteFill>
);
};
Referências
- Documentação do Remotion: https://remotion.dev/docs
- Repositório no GitHub: https://github.com/remotion-dev/remotion
- Modelos: https://remotion.dev/templates
- Discord da Comunidade: https://remotion.dev/discord
Dicas de resolução de problemas
Erro: "O arquivo não pôde ser lido"
- Verifique se o caminho em
staticFile()está correto - Verifique se o ativo está realmente no diretório
public/ - Verifique se o nome do arquivo tem a extensão correta
Erro: "A renderização falhou"
- Verifique se todas as dependências estão instaladas
- Certifique-se de que as dimensões da composição são números pares
- Certifique-se de que você não está usando Math.random sem semente
- Verifique se os dados assíncronos estão sendo carregados corretamente com delayRender
Animação não aparece
- Certifique-se de que você está usando
useCurrentFrame()para obter o quadro atual - Certifique-se de que você está aplicando valores interpolados ou spring aos estilos
- Verifique se a composição tem a duração correta em frames
Considerações finais
Com Remotion, você tem o poder do React para criar vídeos. Lembre-se dos princípios-chave: cada quadro é uma função pura, use as primitivas declarativas para temporização e animação, e sempre garanta que seus ativos estejam no lugar certo. Com esta skill, você pode criar desde animações simples até vídeos personalizados complexos em escala.