Dari laptop 4 GB ke MP4 9:16, tanpa tagihan API.

Tiga runtime saja. Node untuk Remotion, Python untuk suara dan subtitle, FFmpeg untuk menyatukan semuanya. Tidak ada CUDA, tidak ada Docker — di laptop 4 GB, Docker justru merebut RAM yang kamu butuhkan untuk render.

# Wajib ada ketiganya. Kalau salah satu kosong, pasang dulu.
node -v      # butuh v20 atau lebih baru
python3 -V   # butuh 3.10+
ffmpeg -version | head -1

FFmpeg di Windows paling gampang lewat winget install Gyan.FFmpeg, di macOS brew install ffmpeg, di Ubuntu sudo apt install ffmpeg.

Struktur folder

Satu folder induk, dua sub-proyek yang sengaja dipisah: bagian React dan bagian Python tidak perlu tahu satu sama lain, mereka hanya bertukar file.

Ini tahap paling penting dan paling sering dilewati orang. Sebelum membangun apa pun, buktikan dulu mesinmu sanggup mengeluarkan video. Kalau tahap ini lancar, sisanya cuma soal ketekunan.

npx create-video@latest --yes --blank --no-tailwind studio
cd studio
npm install

Lalu timpa isinya dengan file dari paket vid002-lift: src/scenes/Lift.tsx, src/Root.tsx, src/data/recipe.json, dan remotion.config.ts.

npx remotion studio          # preview interaktif, geser timeline
npx remotion still Lift out/cek.png --frame=120   # cek 1 frame, ±10 detik
npx remotion render Lift out/lift.mp4             # render penuh

Kalau render berat atau mati sendiri

• Turunkan Config.setConcurrency(2) jadi 1 di remotion.config.ts. Tiap unit concurrency ≈ satu tab Chrome headless.
• Tutup browser dan Slack saat render. Di laptop 4 GB, ini bukan saran sopan-santun — itu memang penentu berhasil atau tidak.
• Kalau muncul error terkait GPU/WebGL, tambahkan --gl=angle pada perintah render.

Menambah 4 scene sisanya

Di sinilah Claude Code kamu bekerja. Buka terminal di folder studio/ dan minta scene berikutnya dengan referensi konkret — bukan deskripsi abstrak.

claude -p "Baca src/scenes/Lift.tsx. Buat src/scenes/Thrust.tsx
dengan pola koreografi yang sama: mesin jet SVG, api yang
berdenyut, dan panah dorong ke kanan. Ambil durasi dan narasi
dari scene sequence 4 di src/data/recipe.json. Daftarkan
komposisinya di Root.tsx."

Remotion punya skill resmi untuk coding agent, dan ini benar-benar menaikkan kualitas hasilnya:

npx -y skills@latest add remotion-dev/skills -g -y

Piper adalah pilihan yang tepat justru karena keterbatasan mesinmu: model VITS yang diekspor ke ONNX, jalan di CPU, dan satu suara cuma puluhan megabyte. Di CPU desktop modern kecepatannya sekitar 10× realtime — narasi 30 detik selesai dalam hitungan detik.

cd worker
python3 -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install piper-tts

Suara Indonesia yang tersedia resmi adalah id_ID-news_tts-medium — suara pembaca berita, kualitas 22 kHz. Cocok untuk gaya edukasi singkat.

python3 -m piper.download_voices id_ID-news_tts-medium

echo 'Kenapa pesawat bisa terbang?' \
  | piper -m id_ID-news_tts-medium -f uji.wav

Per-scene, bukan sekali panjang

Ini keputusan struktural yang penting. Rekam satu file per scene, bukan satu file 30 detik. Alasannya: kalau kalimat scene 4 perlu direvisi, kamu cukup merekam ulang scene 4. Dan Remotion bisa menaruh tiap audio tepat di <Sequence>-nya masing-masing, jadi sinkronisasi otomatis benar.

import json, wave, pathlib
from piper import PiperVoice

VOICE = PiperVoice.load("id_ID-news_tts-medium.onnx")

def bikin_suara(video_dir: str):
    root = pathlib.Path(video_dir)
    recipe = json.loads((root / "recipe.json").read_text())
    out = root / "voice"; out.mkdir(exist_ok=True)

    for scene in recipe["scenes"]:
        target = out / f"scene-{scene['sequence']:02d}.wav"
        if target.exists():          # sudah ada = lewati, ini inti retry
            continue
        with wave.open(str(target), "wb") as f:
            VOICE.synthesize_wav(scene["narration"], f)
        print("ok", target.name)

Logikanya mungkin terasa terbalik: kita sudah punya teks narasinya, kenapa masih perlu speech-to-text? Karena yang kita cari bukan teksnya — tapi kapan tiap kata diucapkan. Itulah yang membuat caption meletup per kata seperti di Shorts, dan retensi penonton naik karenanya.

Jalur A — whisper.cpp lewat Remotion (disarankan)

Paling pas untuk mesinmu: whisper.cpp dioptimalkan untuk CPU, dan hasilnya langsung berbentuk objek Caption yang dimengerti Remotion. Satu skrip Node, tanpa Python sama sekali.

npm i --save-exact @remotion/install-whisper-cpp @remotion/captions

import path from 'path';
import fs from 'fs';
import {execSync} from 'child_process';
import {
  installWhisperCpp, downloadWhisperModel, transcribe, toCaptions,
} from '@remotion/install-whisper-cpp';

const to = path.join(process.cwd(), 'whisper.cpp');
await installWhisperCpp({to, version: '1.5.5'});
await downloadWhisperModel({model: 'small', folder: to});
// 'small' (bukan small.en) — versi .en tidak bisa bahasa Indonesia

const wav = process.argv[2];
const wav16 = wav.replace('.wav', '-16k.wav');
execSync(`ffmpeg -i ${wav} -ar 16000 -ac 1 ${wav16} -y`);
// whisper.cpp hanya menerima WAV 16-bit 16 kHz mono

const hasil = await transcribe({
  inputPath: wav16,
  whisperPath: to,
  whisperCppVersion: '1.5.5',
  model: 'small',
  language: 'id',
  tokenLevelTimestamps: true,   // ini yang bikin timing per kata akurat
});

const {captions} = toCaptions({whisperCppOutput: hasil});
fs.writeFileSync('public/captions.json', JSON.stringify(captions, null, 2));

Di dalam scene, kelompokkan kata jadi "halaman" caption dengan createTikTokStyleCaptions() dari @remotion/captions — itu yang menghasilkan ritme baca khas Shorts tanpa kamu menghitung frame manual.

Jalur B — faster-whisper (Python)

Pakai ini kalau kamu lebih nyaman di Python atau ingin transkripnya dipakai di luar Remotion juga.

# pip install faster-whisper
from faster_whisper import WhisperModel

model = WhisperModel("small", device="cpu", compute_type="int8")
# int8 di CPU: ±4x lebih cepat daripada fp16, RAM jauh lebih hemat

segments, info = model.transcribe(
    "voice/scene-03.wav",
    language="id",
    word_timestamps=True,
    vad_filter=True,
)

kata = [
    {"text": w.word, "startMs": round(w.start * 1000), "endMs": round(w.end * 1000)}
    for seg in segments for w in seg.words
]

Resep adalah kontrak antara bagian AI dan bagian render. Selama bentuknya benar, sumbernya tidak penting — mau dari Gemini, dari Claude, atau kamu ketik sendiri. Karena itu jangan mulai dari "LLM mana yang dipakai", tapi dari "seperti apa bentuk JSON-nya".

Aturan yang harus dijaga

• Setiap scene wajib punya component yang sudah ada file .tsx-nya. Kalau LLM mengarang component: "Explosion" sementara komponennya tidak ada, render gagal. Kirimkan daftar komponen yang tersedia di dalam prompt.
• Total duration semua scene harus sama dengan duration video. Validasi ini menangkap 90% resep rusak.
• Narasi ditulis untuk didengar, bukan dibaca. Kalimat pendek, tanpa tanda kurung, angka ditulis sebagaimana diucapkan.

KOMPONEN = {"Hook", "Intro", "Lift", "Thrust", "DragWeight"}

def periksa(r: dict) -> list[str]:
    salah = []
    total = sum(s["duration"] for s in r["scenes"])
    if total != r["duration"]:
        salah.append(f"total scene {total} dtk != durasi video {r['duration']} dtk")
    for s in r["scenes"]:
        if s["component"] not in KOMPONEN:
            salah.append(f"komponen tak dikenal: {s['component']}")
        if len(s["narration"]) > 220:
            salah.append(f"scene {s['sequence']}: narasi kepanjangan")
    return salah

Dua cara menghasilkan resep

Blueprint menyebut PostgreSQL, Redis, dan MinIO. Untuk satu laptop dan satu operator, ketiganya adalah biaya RAM tanpa manfaat. Ganti dengan yang setara tapi gratis dan ringan: filesystem sebagai storage, SQLite sebagai database, dan status.json sebagai antrean.

Kunci desainnya bukan pada tool, tapi pada satu ide: setiap tahap harus bisa dijalankan ulang tanpa merusak apa pun. Kalau outputnya sudah ada, tahap itu melewati dirinya sendiri. Dengan begitu retry tidak perlu logika khusus — cukup jalankan ulang seluruhnya.

import sys, json, subprocess, pathlib

TAHAP = [
    ("RESEARCH",          "research.json"),
    ("SCRIPT_DRAFT",      "recipe.json"),
    ("SCRIPT_APPROVED",   "approved.flag"),   # disentuh manusia
    ("VOICE_GENERATION",  "voice/scene-01.wav"),
    ("SUBTITLE",          "captions/captions.json"),
    ("RENDERED",          "out/final.mp4"),
]

def jalankan(vid: str):
    root = pathlib.Path("../videos") / vid
    for nama, penanda in TAHAP:
        if (root / penanda).exists():
            print(f"lewati {nama} — sudah ada")
            continue
        print(f"jalankan {nama}")
        try:
            subprocess.run(["python", f"steps/{nama.lower()}.py", vid], check=True)
        except subprocess.CalledProcessError:
            tulis_status(root, f"FAILED_{nama}")
            print(f"berhenti di {nama}. Perbaiki, lalu jalankan perintah yang sama.")
            return
        tulis_status(root, nama)
    print("selesai — MP4 siap direview")

def tulis_status(root, status):
    (root / "status.json").write_text(json.dumps({"status": status}))

if __name__ == "__main__":
    jalankan(sys.argv[1])

Back-office yang sudah kita buat adalah tampilan dari data ini. Kalau nanti mau menyambungkannya, cukup sajikan folder videos/ sebagai JSON lewat satu endpoint kecil, dan ganti data dummy di halaman Dashboard dengan hasil fetch.

Remotion sudah menghasilkan MP4 lengkap dengan audio, jadi FFmpeg di sini bukan untuk menggabung — melainkan untuk memastikan hasil akhirnya benar-benar sesuai spesifikasi Shorts, dan untuk mengambil thumbnail.

# Pastikan 1080x1920, H.264, AAC, faststart untuk streaming
ffmpeg -i out/final.mp4 \
  -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:-1:-1" \
  -c:v libx264 -preset medium -crf 22 -pix_fmt yuv420p \
  -c:a aac -b:a 128k -movflags +faststart \
  out/VID-002-final.mp4 -y

# Thumbnail dari detik ke-2
ffmpeg -i out/VID-002-final.mp4 -ss 2 -frames:v 1 out/thumb.jpg -y

Totalnya: sekitar 10–25 menit per video, hampir seluruhnya terpakai untuk render. Artinya realistis 2–4 video sehari sambil laptopnya tetap kamu pakai bekerja, atau lebih banyak kalau dijalankan malam hari secara batch.

Kapan pantas mulai membayar

Urutan yang masuk akal kalau nanti ada anggaran, dari yang paling terasa dampaknya:

1. VPS untuk render (~Rp 150–300rb/bulan). Ini yang pertama, bukan AI-nya. Laptopmu bebas dan render bisa jalan semalaman.
2. TTS berbayar kalau suara Piper terasa membatasi setelah kamu punya penonton tetap. Kualitas suara berpengaruh besar pada retensi.
3. AI image paling akhir, dan hanya untuk video yang memang butuh foto realistis. Video infografik tidak pernah membutuhkannya.

Masalah yang hampir pasti kamu temui

Angka waktu di runbook ini adalah perkiraan untuk laptop kelas menengah tanpa akselerasi GPU; mesinmu bisa berbeda cukup jauh. Yang tidak berubah adalah urutannya: setiap tahap berhenti di sesuatu yang bisa dibuka dan ditonton, supaya kamu selalu tahu persis di mana posisimu. Centangan di halaman ini tidak tersimpan setelah tab ditutup.