Multimodal · Generative video
AI-Video-Gen
Type a topic and get a narrated 1080p video presentation — AI-generated script, multilingual voiceover, and visuals composed end-to-end.
Demo
Watch it in action
The walkthrough video will live here — script, output, and runtime demo in one take.
Recording in progress
Project details
What it does, end to end
- Team project (4 members, IIIT Dharwad) built around five backend generators: script, content, voice, image, and Manim animation.
- User sets topic, slide count, language, and tone; the pipeline returns a finished MP4.
- Each slide is text, an image, or an animation — rendered and composed by FFmpeg into a 1080p video.
- Live progress streaming: Server-Sent Events push each stage (content → audio → visuals → render) to the UI as it completes.
2025 — 2026 · Team of 4
Tech stack
Built with
Architecture
How it works
Problem & solution
Why it exists
Problem
Making a good presentation video — script, narration, visuals — usually takes hours of recording and editing tools. Non-designers and students rarely have that time.
Solution
A single pipeline that generates the script, narrates it in the chosen language, picks or animates visuals, and renders the final MP4 — with live progress so users watch it happen.
Technical details
Under the hood
- FastAPI backend with modular generators and a video composer/renderer util layer.
- Gemini for script and content generation; Sarvam AI (bulbul:v1) for multilingual TTS; Unsplash API for imagery; Manim for math/explainer animations.
- React + Vite frontend with a slide editor, live preview, and video player.
- useSSEProgress hook drives a step-by-step progress UI from the backend event stream.
Impacts
What changed
- Turns lecture notes and pitch topics into presentable videos in minutes rather than hours.
- Multilingual voiceover makes the same deck usable in multiple languages without re-recording.
- Won recognition in campus showcases as one of the first end-to-end video pipelines built by a student team.
Learnings
Lessons that stuck
- 01Orchestrating five independent generators (each with API limits and failure modes) is the hard 80% — the pipeline's reliability is its real feature.
- 02SSE is the right tool for long multi-stage jobs: the UI stays alive and honest about what's happening.
- 03Delegation works: splitting work by module (backend / frontend / infra) across four people keeps merge pain low.
- 04Never assume an external API behaves — every generator needs a graceful fallback.
Challenges & mistakes
What broke, and what it taught me
Mistake 01
Setup was Windows-only and brittle — FFmpeg and Manim path issues made the first install a saga.
Lesson learned
Document installs as part of the product; future pipelines get containerized environments from day one.
Mistake 02
Generator APIs (Gemini, Sarvam, Unsplash) each have rate limits that surfaced mid-demo.
Lesson learned
Treat third-party calls as flaky by default: retries, timeouts, and cached outputs turned a demo-killer into a non-event.
Mistake 03
Long renders with no feedback made users think the app hung.
Lesson learned
Ship progress streaming (SSE) before polish — perceived speed matters as much as speed.