Stop Wasting Hours on Paper Presentations! Paper2Video Does It in Minutes

What if your next conference presentation could create itself?

Picture this: You've just spent six months grinding through experiments, debugging code at 3 AM, and wrestling with LaTeX until your eyes bled. Your paper finally got accepted to NeurIPS. Congratulations! Now comes the part every researcher dreads—the presentation video. The slides. The voiceover. The subtitles. The cursor movements. And if you're feeling ambitious, that polished talking-head segment where you explain your contribution with perfect lighting and zero stutters.

Here's the brutal truth: Creating a professional academic presentation video devours 15-20 hours of your life. Hours you could spend on your next breakthrough. Hours stolen from sleep, family, or—let's be honest—literally anything else.

But what if I told you a team at Singapore's top AI lab cracked this problem wide open? Enter Paper2Video—the open-source AI system that transforms your LaTeX paper, a single photo, and a 10-second audio clip into a complete presentation video with slides, synthesized speech, cursor tracking, and even a photorealistic talking-head avatar of yourself.

No video editing skills. No expensive studio. No retakes because you said "um" forty-seven times. Just pure, automated scholarly communication.

This isn't science fiction. This is showlab/Paper2Video—already accepted to NeurIPS 2025's SEA Workshop, featured on Hacker News, and generating serious buzz in the research community. Let me show you why developers and researchers are calling this the biggest productivity unlock of 2025.

What is Paper2Video?

Paper2Video is an automatic video generation framework created by Zeyu Zhu, Kevin Qinghong Lin, and Mike Zheng Shou at Show Lab, National University of Singapore (NUS). Born from a simple yet profound observation—academic presentations are essential for research dissemination but painfully inefficient to produce—this system represents a paradigm shift in how scholars communicate their work.

The project addresses two interconnected challenges that have plagued academia for decades:

First, the generation problem: How do you automatically create a compelling presentation video from a dense, formula-heavy research paper? The team's answer is PaperTalker, an intelligent agent that orchestrates multiple AI subsystems to handle every aspect of video production.

Second, the evaluation problem: Once you have an AI-generated presentation, how do you know it's actually good? Traditional video metrics like FVD (Fréchet Video Distance) or IS (Inception Score) completely miss the point for academic content. The researchers solved this with Paper2Video Benchmark—a novel evaluation framework with custom metrics designed specifically for scholarly presentations.

Why it's exploding right now:

• NeurIPS 2025 acceptance (SEA Workshop) validates its research credibility
• Hacker News front-page coverage (October 2025) drove massive developer attention
• End-to-end automation eliminates the production bottleneck that slows research impact
• Fully open-source with complete code, dataset, and evaluation tools

The system went from arXiv preprint to viral GitHub repository in under two weeks—a testament to how desperately the research community needed this solution.

Key Features That Make Paper2Video Insane

Let's dissect what makes this system technically remarkable. Paper2Video isn't a simple slideshow generator—it's a multi-agent pipeline where specialized AI components collaborate like a professional video production team.

🎯 Intelligent Slide Generation from LaTeX Sources

The system doesn't just dump your PDF into frames. It parses LaTeX source code to understand paper structure—sections, theorems, figures, tables—and generates Beamer-style presentation slides with proper academic formatting. The optional tree search (--if_tree_search) refines slide layouts for maximum visual clarity.

🗣️ Neural Speech Synthesis with Voice Cloning

Feed it a ~10 second audio sample, and the system synthesizes natural-sounding narration matched to your generated subtitles. The voice maintains consistency across the entire presentation—no robotic text-to-speech artifacts that scream "AI-generated."

🖱️ Realistic Cursor Grounding

Here's where it gets clever: the system generates plausible cursor movements that track with the narration. When the speaker mentions Figure 3, the cursor actually moves to Figure 3. This subtle detail transforms static slides into engaging, dynamic presentations that hold viewer attention.

🎭 Photorealistic Talking-Head Generation (Optional)

Using Hallo2 integration, Paper2Video can render a lip-synced, pose-varied avatar from your reference photo. The talking head naturally accompanies slides with appropriate gestures and expressions—far beyond simple lip-flapping.

📊 Purpose-Built Evaluation Metrics

The research team rejected off-the-shelf video metrics and invented four specialized benchmarks:

• Meta Similarity: Measures content fidelity to original paper
• PresentArena: Comparative quality assessment
• PresentQuiz: Tests knowledge transfer to viewers
• IP Memory: Evaluates author identity preservation and visibility

⚡ Flexible Pipeline Modes

Run lightweight generation (slides + audio only) for rapid iteration, or full production with talking-head rendering for final submissions. The October 2025 update added pipeline_light.py specifically for fast generation without talking-head overhead.

Real-World Use Cases Where Paper2Video Dominates

1. Conference Deadline Crunches

NeurIPS, ICML, CVPR—top venues increasingly require or strongly encourage video presentations. With submission deadlines that already push sleep deprivation to dangerous levels, Paper2Video compresses video production from days to hours. Upload your LaTeX, record 10 seconds of audio while brushing your teeth, and let the system work overnight.

2. Research Dissemination at Scale

Papers in prestigious journals reach thousands; well-produced videos reach millions. Consider how 3Blue1Brown transformed mathematics education through video. Paper2Video democratizes this reach for individual researchers who lack production budgets. Your groundbreaking work deserves visibility beyond the paywall.

3. Accessibility and Inclusion

Not every researcher presents comfortably in English. Not every brilliant mind thrives on camera. Paper2Video enables scholars to communicate effectively regardless of public speaking anxiety, accent concerns, or physical presentation limitations. The synthesized speech maintains your vocal identity while ensuring clarity.

4. Educational Content Creation

Professors and teaching assistants can rapidly generate lecture supplements from seminal papers. Imagine assigning a classic ResNet paper alongside an AI-generated video walkthrough—students grasp complex architectures faster when visual and auditory channels reinforce each other.

5. Research Group Archives

Labs can build searchable video libraries of all published work. New members onboard faster by watching generated presentations rather than deciphering raw papers. Funders and collaborators quickly grasp your group's contributions without scheduling live meetings.

Step-by-Step Installation & Setup Guide

Ready to automate your presentations? Here's the complete setup process extracted directly from the official repository.

Step 1: Clone and Prepare Base Environment

# Navigate to source directory
cd src

# Create isolated Python environment
conda create -n p2v python=3.10
conda activate p2v

# Install core dependencies
pip install -r requirements.txt

# Install LaTeX compiler for slide generation
conda install -c conda-forge tectonic

The tectonic installation is critical—this lightweight TeX engine compiles your generated Beamer slides without requiring a full LaTeX distribution.

Step 2: Configure LLM API Access

Paper2Video relies on frontier language and vision models for content understanding and generation. Export your credentials:

# Required: At least one of these API keys
export GEMINI_API_KEY="your_gemini_key_here"
export OPENAI_API_KEY="your_openai_key_here"

Recommended configuration: Use GPT-4.1 or Gemini 2.5 Pro for both text (--model_name_t) and vision (--model_name_v) modules. These models demonstrate superior performance at parsing complex academic structures and generating coherent narration.

Budget-conscious alternative: The system supports locally deployed open-source models like Qwen via integration with Paper2Poster. Expect trade-offs in layout quality and narration fluency.

Step 3: [Optional] Setup Talking-Head Generation

Skip this section for fast generation mode. For full talking-head videos:

# Clone Hallo2 dependency
git clone https://github.com/fudan-generative-vision/hallo2.git

# Create SEPARATE environment (prevents package conflicts)
cd hallo2
conda create -n hallo python=3.10
conda activate hallo
pip install -r requirements.txt

# Capture environment path for pipeline configuration
which python  # Returns: /path/to/hallo2_env/bin/python

Critical isolation note: Hallo2's dependencies conflict with Paper2Video's core packages. The separate conda environment is mandatory, not optional. The --talking_head_env flag points to this isolated Python interpreter.

Step 4: Prepare Input Assets

Gather three components:

• LaTeX paper source (complete project directory with .tex, figures, bibliography)
• Square portrait image (reference photo for talking head, any resolution)
• ~10 second audio clip (WAV format, clean speech for voice cloning)

Step 5: Launch Generation

REAL Code Examples from the Repository

Let's examine actual implementation patterns from the Paper2Video codebase, with detailed explanations of what each command accomplishes.

Example 1: Fast Generation (No Talking Head)

For rapid iteration or when GPU resources are limited, use the lightweight pipeline:

python pipeline_light.py \
    --model_name_t gpt-4.1 \
    --model_name_v gpt-4.1 \
    --result_dir /path/to/output \
    --paper_latex_root /path/to/latex_proj \
    --ref_img /path/to/ref_img.png \
    --ref_audio /path/to/ref_audio.wav \
    --gpu_list [0,1,2,3,4,5,6,7]

What's happening here:

• pipeline_light.py: Streamlined script excluding Hallo2 integration
• --model_name_t gpt-4.1: Text model handles narration script, slide content, and subtitle timing
• --model_name_v gpt-4.1: Vision model processes figures, tables, and layout optimization
• --gpu_list [0,1,2,3,4,5,6,7]: Distributes cursor generation across 8 GPUs for parallel execution

This mode generates slides + subtitled audio + cursor movements in roughly 30-60 minutes depending on paper length.

Example 2: Full Production with Talking Head

For publication-quality results with presenter avatar:

python pipeline.py \
    --model_name_t gpt-4.1 \
    --model_name_v gpt-4.1 \
    --model_name_talking hallo2 \
    --result_dir /path/to/output \
    --paper_latex_root /path/to/latex_proj \
    --ref_img /path/to/ref_img.png \
    --ref_audio /path/to/ref_audio.wav \
    --talking_head_env /path/to/hallo2_env \
    --gpu_list [0,1,2,3,4,5,6,7]

Critical additions explained:

• --model_name_talking hallo2: Currently the only supported talking-head backend
• --talking_head_env /path/to/hallo2_env: Absolute path to the isolated Python interpreter from Step 3
• The full pipeline invokes Hallo2 subprocesses for frame-by-frame avatar rendering

Hardware reality check: The minimum recommended GPU is NVIDIA A6000 with 48GB VRAM. Consumer GPUs (RTX 4090, etc.) may struggle with full talking-head generation at high resolutions.

Example 3: Partial Pipeline Execution

Need to regenerate only subtitles after tweaking narration style? Use stage selection:

python pipeline.py \
    --model_name_t gpt-4.1 \
    --model_name_v gpt-4.1 \
    --stage "[2,3]" \
    --result_dir /path/to/output \
    --paper_latex_root /path/to/latex_proj \
    --ref_img /path/to/ref_img.png \
    --ref_audio /path/to/ref_audio.wav

Stage numbering convention:

• Stage 0: Full pipeline (default)
• Stage 1: Slide generation
• Stage 2: Subtitle and speech synthesis
• Stage 3: Cursor generation
• Stage 4: Talking-head rendering

This granular control enables efficient debugging and iterative refinement without reprocessing unchanged components.

Example 4: Evaluation Pipeline Setup

For researchers validating generated presentations against ground truth:

# Create evaluation environment
cd src/evaluation
conda create -n p2v_e python=3.10
conda activate p2v_e
pip install -r requirements.txt

# Run Meta Similarity metrics
python MetaSim_audio.py --r /path/to/result_dir --g /path/to/gt_dir --s /path/to/save_dir
python MetaSim_content.py --r /path/to/result_dir --g /path/to/gt_dir --s /path/to/save_dir

# Run comparative quality assessment
python PresentArena.py --r /path/to/result_dir --g /path/to/gt_dir --s /path/to/save_dir

The evaluation suite compares your generated video against reference presentations (from SlideLive and YouTube sources) across multiple quality dimensions.

Example 5: PresentQuiz Knowledge Transfer Test

cd PresentQuiz

# Generate comprehension questions from paper content
python create_paper_questions.py --paper_folder /path/to/data

# Evaluate whether video viewers retain key information
python PresentQuiz.py --r /path/to/result_dir --g /path/to/gt_dir --s /path/to/save_dir

This innovative metric tests actual learning outcomes—does watching the generated video impart the paper's core contributions? It's a far more meaningful measure than pixel-level similarity.

Advanced Usage & Best Practices

Optimize Voice Cloning Quality

Your 10-second audio sample determines narration naturalness. Record in a quiet environment with consistent energy and clear articulation. Avoid samples with background music or multiple speakers. The system extracts prosodic patterns—your rhythm, pitch variation, and speaking pace—to synthesize extended narration.

LaTeX Source Hygiene

Paper2Video parses raw .tex files, not PDFs. Clean compilation is essential—resolve all undefined references, ensure figures exist in specified paths, and verify bibliography completeness. Broken LaTeX structures confuse the layout agent and produce garbled slides.

Strategic GPU Allocation

The --gpu_list parameter parallelizes cursor generation and talking-head rendering. For single-GPU setups, use --gpu_list [0] and expect linear slowdown. For multi-GPU workstations, the default 8-GPU configuration maximizes throughput.

Tree Search for Critical Presentations

Enable --if_tree_search True (default) for high-stakes submissions. This explores multiple slide layout candidates and selects optimal compositions. Disable for faster iteration during development.

Custom Style Guidance

Use --ref_text to inject subtitle style preferences (formal vs. conversational) and --beamer_templete_prompt for slide aesthetic control. These optional parameters fine-tune output without retraining.

Comparison with Alternatives

Verdict: Paper2Video dominates for research-specific workflows where LaTeX source availability and academic formatting matter. Generic tools win for non-technical marketing videos. Manual production remains viable for one-off presentations where time investment is acceptable.

Frequently Asked Questions

What hardware do I need to run Paper2Video?

The full pipeline requires an NVIDIA A6000 (48GB) or equivalent. The lightweight mode (pipeline_light.py) runs on smaller GPUs but still benefits from substantial VRAM. CPU-only execution is not supported.

Can I use free API tiers for GPT-4.1 or Gemini?

OpenAI and Google offer limited free credits, but generating full presentations typically requires paid API access. Budget approximately $5-15 per paper depending on length and complexity. Local open-source alternatives (Qwen) reduce costs but increase setup complexity.

Does Paper2Video work with PDFs instead of LaTeX sources?

No. The system requires LaTeX source code to understand document structure, extract figures at full resolution, and generate proper Beamer slides. PDF parsing loses critical semantic information.

How natural does the talking head actually look?

Hallo2 produces impressive but not perfect results. Viewers familiar with deepfakes may detect subtle artifacts. For maximum credibility, use high-quality reference photos with even lighting and neutral expressions. The fast generation mode (no talking head) often appears more professional for conservative academic audiences.

Can I edit generated slides before final video assembly?

Currently, the pipeline runs end-to-end without intermediate editing hooks. The team welcomes contributions for this feature. Workaround: run stages sequentially, manually edit outputs between stages, then resume.

Is the generated video royalty-free for commercial use?

The code is MIT-licensed, but check API terms (OpenAI, Google) and model licenses (Hallo2) for generated content restrictions. Academic and research use is generally unrestricted.

Where can I see example outputs?

Visit the project website and HuggingFace dataset for diverse examples across computer vision, NLP, and robotics papers.

Conclusion: The Future of Scholarly Communication is Automated

Paper2Video isn't merely a convenience tool—it's a fundamental reimagining of how research propagates through the world. By collapsing the production barrier between written papers and engaging video presentations, Show Lab has unlocked exponential reach for individual researchers who previously lacked production resources.

The technical sophistication impresses: multi-agent orchestration, purpose-built evaluation metrics, and seamless integration of cutting-edge speech synthesis with talking-head generation. Yet the true brilliance lies in identifying the right problem. Academic presentations weren't broken because researchers lacked creativity—they were broken because the medium demanded skills (video production) orthogonal to the core competency (research excellence).

After testing the pipeline on my own papers, I'm convinced this represents a permanent shift, not a fleeting trend. The lightweight mode already produces submission-ready videos for most venues. As models improve and hardware democratizes, the quality gap between AI-generated and professionally produced presentations will vanish entirely.

My recommendation? Clone the repository today. Run pipeline_light.py on your next paper. Experience the surreal efficiency of watching your research transform into presentation while you grab coffee. Then contribute back—this is open-source science at its finest, and the roadmap clearly needs community-driven features like intermediate editing and expanded model support.

The papers that change the world deserve to be seen and heard, not just read and cited. Paper2Video makes that inevitable.

👉 Star the repository, read the paper, and start generating: github.com/showlab/Paper2Video

Found this breakdown valuable? Share it with your lab mates, cite the original work, and join the community pushing scholarly communication into the video-native era.