alterlab-paper-2-web

Paper2All: Academic Paper Transformation Pipeline

Overview

This skill enables the transformation of academic papers into multiple promotional and presentation formats using the Paper2All autonomous pipeline. The system converts research papers (LaTeX or PDF) into three primary outputs:

Paper2Web: Interactive, explorable academic homepages with layout-aware design
Paper2Video: Professional presentation videos with narration, slides, and optional talking-head
Paper2Poster: Print-ready conference posters with professional layouts

The pipeline uses LLM-powered content extraction, design generation, and iterative refinement to create high-quality outputs suitable for conferences, journals, preprint repositories, and academic promotion.

When to Use This Skill

Use this skill when:

Creating conference materials: Posters, presentation videos, and companion websites for academic conferences
Promoting research: Converting published papers or preprints into accessible, engaging web formats
Preparing presentations: Generating video abstracts or full presentation videos from paper content
Disseminating findings: Creating promotional materials for social media, lab websites, or institutional showcases
Enhancing preprints: Adding interactive homepages to bioRxiv, arXiv, or other preprint submissions
Batch processing: Generating promotional materials for multiple papers simultaneously

Trigger phrases:

"Convert this paper to a website"
"Generate a conference poster from my LaTeX paper"
"Create a video presentation from this research"
"Make an interactive homepage for my paper"
"Transform my paper into promotional materials"
"Generate a poster and video for my conference talk"

Does NOT Trigger

Scenario	Use Instead
Hand-building a LaTeX research poster (beamerposter, tikzposter, baposter)	`alterlab-latex-posters`
A PowerPoint/PPTX or HTML poster the user will edit themselves	`alterlab-pptx-posters`
Designing and delivering a slide deck for a live talk	`alterlab-scientific-slides`
Posting the paper to arXiv, bioRxiv, medRxiv, or SSRN	`alterlab-preprint-deposition`

Visual Enhancement with Scientific Schematics

If a diagram or figure would aid comprehension, invoke the alterlab-scientific-schematics skill (diagrams/schematics) or the alterlab-generate-image skill (images). Figures are optional — add them only where they improve clarity.

Core Capabilities

1. Paper2Web: Interactive Website Generation

Converts papers into layout-aware, interactive academic homepages that go beyond simple HTML conversion.

Key Features:

Responsive, multi-section layouts adapted to paper content
Interactive figures, tables, and citations
Mobile-friendly design with navigation
Automatic logo discovery (with Google Search API)
Aesthetic refinement and quality assessment

Best For: Post-publication promotion, preprint enhancement, lab websites, permanent research showcases

→ See references/paper2web.md for detailed documentation

2. Paper2Video: Presentation Video Generation

Generates professional presentation videos with slides, narration, cursor movements, and optional talking-head video.

Key Features:

Automated slide generation from paper structure
Natural-sounding speech synthesis
Synchronized cursor movements and highlights
Optional talking-head video using Hallo2 (requires GPU)
Multi-language support

Best For: Video abstracts, conference presentations, online talks, course materials, YouTube promotion

→ See references/paper2video.md for detailed documentation

3. Paper2Poster: Conference Poster Generation

Creates print-ready academic posters with professional layouts and visual design.

Key Features:

Custom poster dimensions (any size)
Professional design layouts
High-resolution, print-ready output
QR codes / institution logos may need to be added manually (not documented pipeline flags)

Best For: Conference poster sessions, symposiums, academic exhibitions, virtual conferences

→ See references/paper2poster.md for detailed documentation

Quick Start

Prerequisites

Install Paper2All:
```
git clone https://github.com/YuhangChen1/Paper2All.git
cd Paper2All
conda create -n p2w python=3.11
conda activate p2w
pip install -r requirements.txt
```
Paper2Video runs in its own environment (conda create -n p2v python=3.10), and the optional talking-head module in a third (conda create -n hallo python=3.10).

Configure API Keys:

# pipeline_all.py (website, poster, PR) reads only this variable, from the shell
# environment (it does not load .env) and exits if it is unset:
export OPENROUTER_API_KEY=sk-or-...

# .env in the repo root — read by the sub-modules and Paper2Video
OPENAI_API_KEY=your_key_here
OPENAI_API_BASE=https://openrouter.ai/api/v1   # upstream-recommended; or https://api.openai.com/v1
# Optional: GOOGLE_SEARCH_API_KEY and GOOGLE_SEARCH_ENGINE_ID for logo search

The AutoPR component has its own AutoPR/.env (copy AutoPR/.env.example). Paper content is sent to these third-party model providers — confirm that is acceptable for unpublished work.

Install System Dependencies:
- LibreOffice (document conversion)
- Poppler utilities (PDF processing)
- NVIDIA GPU with 48GB (optional, for talking-head videos)

→ See references/installation.md for complete installation guide

Basic Usage

pipeline_all.py drives the website, poster, and PR-material modules from a PDF. The --model-choice flag selects which component(s) to run (one or more of 1 2 3) — it is NOT a model selector. Omit it to run all modules. The output flag is --output_dir (underscore): the upstream README shows a hyphenated --output-dir, which the script's argument parser rejects. pipeline_all.py processes only the first PDF it finds under --input-dir (a paper.pdf inside each subfolder, or a PDF directly in the folder); pass --pdf-path to choose one explicitly.

`--model-choice`	Component
(omitted)	All modules
`1`	Website (Paper2Web) only
`2`	Poster (Paper2Poster) only
`3`	PR materials (AutoPR) only

Generate Everything (website + poster + PR materials):

python pipeline_all.py \
  --input-dir "path/to/paper" \
  --output_dir "path/to/output"

Generate Website Only:

python pipeline_all.py \
  --input-dir "path/to/paper" \
  --output_dir "path/to/output" \
  --model-choice 1

Generate Poster with Custom Size (default is 48 × 36 in landscape):

python pipeline_all.py \
  --input-dir "path/to/paper" \
  --output_dir "path/to/output" \
  --model-choice 2 \
  --poster-width-inches 60 \
  --poster-height-inches 40

Generate Video (separate p2v environment, lightweight pipeline — no talking-head):

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/paper"

For the full video pipeline with a Hallo2 talking-head, use pipeline.py with --ref_img, --ref_audio, and --gpu_list (requires the hallo env and an NVIDIA A6000 48GB GPU).

→ See references/usage_examples.md for comprehensive workflow examples

Workflow Decision Tree

Use this decision tree to determine which components to generate:

User needs promotional materials for paper?
│
├─ Need permanent online presence?
│  └─→ Generate Paper2Web (interactive website)
│
├─ Need physical conference materials?
│  ├─→ Poster session? → Generate Paper2Poster
│  └─→ Oral presentation? → Generate Paper2Video
│
├─ Need video content?
│  ├─→ Journal video abstract? → Generate Paper2Video (5-10 min)
│  ├─→ Conference talk? → Generate Paper2Video (15-20 min)
│  └─→ Social media? → Generate Paper2Video (1-3 min)
│
└─ Need complete package?
   └─→ Generate all three components

Input Requirements

Supported Input Formats

1. LaTeX Source (Recommended):

paper_directory/
├── main.tex              # Main paper file
├── sections/             # Optional: split sections
├── figures/              # All figure files
├── tables/               # Table files
└── bibliography.bib      # References

2. PDF:

High-quality PDF with embedded fonts
Selectable text (not scanned images)
High-resolution figures (300+ DPI preferred)

Which input each tool takes: pipeline_all.py (website, poster, PR) reads the PDF; Paper2Video (pipeline_light.py / pipeline.py) reads the LaTeX project via --paper_latex_root. Keep both in the paper folder if you want every output.

Input Organization

Single Paper:

input/
└── paper_name/
    ├── paper.pdf          # read by pipeline_all.py
    ├── main.tex           # LaTeX project root for Paper2Video
    ├── figures/
    └── bibliography.bib

Multiple Papers: give each paper its own folder and run pipeline_all.py once per folder (see Batch Processing) — a single run only processes the first PDF it finds.

Common Parameters

Component Selection (`pipeline_all.py`)

--model-choice 1: Website (Paper2Web) only
--model-choice 2: Poster (Paper2Poster) only
--model-choice 3: PR materials (AutoPR) only
(omit --model-choice): Run all modules

Model Selection (video pipeline)

--model_name_t: Model for text/script generation (default gpt-4.1)
--model_name_v: Model for visual/slide generation (default gpt-4.1)

These are Paper2Video aliases resolved in wei_utils.get_agent_config (e.g. gpt-4.1, gpt-4.1-mini, 4o, o3, gpt-5); unrecognized names fall through to a generic OpenAI-compatible client.

Poster Customization (`pipeline_all.py`)

--poster-width-inches [width]: Custom poster width
--poster-height-inches [height]: Custom poster height

Output Structure

pipeline_all.py writes one subfolder per component under --output_dir; Paper2Video writes to its own --result_dir:

output/
├── website/    # Paper2Web (PWAgent) site
├── poster/     # Paper2Poster output copied from the module's generated_posters folder
└── PR/         # AutoPR promotional copy

Give each paper its own --output_dir, because the component folders are not namespaced by paper.

Best Practices

Input Preparation

Use LaTeX when possible: Provides best content extraction and structure
Organize files properly: Keep all assets (figures, tables, bibliography) in paper directory
High-quality figures: Use vector formats (PDF, SVG) or high-resolution rasters (300+ DPI)
Clean LaTeX: Remove compilation artifacts, ensure source compiles successfully

Model Selection Strategy

pipeline_all.py exposes no model flag: the website agent and the poster module call models hard-coded upstream and routed through OpenRouter (Qwen3/Qwen2.5-VL models for the website agent and GPT-4o for Paper2Poster at the time of writing — check the repo if this matters to you). Only the video pipeline takes explicit --model_name_t / --model_name_v overrides:

Stronger models (e.g. the default gpt-4.1): best for production-quality videos
Cheaper/faster aliases (e.g. gpt-4.1-mini): fine for quick drafts, testing, or simple papers

Component Priority

For tight deadlines, generate in this order:

Website (fastest, most versatile, ~15-30 min)
Poster (moderate speed, for print deadlines, ~10-20 min)
Video (slowest, can be generated later, ~20-60 min)

Quality Assurance

Before finalizing outputs:

Website: Test on multiple devices, verify all links work, check figure quality
Poster: Print test page, verify text readability from 3-6 feet, check colors
Video: Watch entire video, verify audio synchronization, test on different devices

Resource Requirements

Processing Time

Rough, unbenchmarked estimates — actual time depends on paper length, models, and hardware:

Website: 15-30 minutes per paper
Poster: 10-20 minutes per paper
Video (no talking-head): 20-60 minutes per paper
Video (with talking-head): 60-120 minutes per paper

Computational Requirements

CPU: Multi-core processor for parallel processing
RAM: 16GB minimum, 32GB recommended for large papers
GPU: Optional for standard outputs, required for talking-head (NVIDIA A6000 48GB)
Storage: 1-5GB per paper depending on components and quality settings

API Costs

Upstream publishes no cost figures, and cost depends on the models routed through OpenRouter/OpenAI and on paper length. Run one paper first and check usage in your provider dashboard before batch processing.

Troubleshooting

Common Issues

LaTeX parsing errors:

Ensure LaTeX source compiles successfully: pdflatex main.tex
Check all referenced files are present
Verify no custom packages prevent parsing

Poor figure quality:

Use vector formats (PDF, SVG, EPS) instead of rasters
Ensure raster images are 300+ DPI
Check figures render correctly in compiled PDF

Video generation failures:

Verify sufficient disk space (5GB+ recommended)
Check all dependencies installed (LibreOffice, Poppler)
Review error logs in output directory

Poster layout issues:

Verify poster dimensions are reasonable (24"-72" range)
Check content length (very long papers may need manual curation)
Ensure figures have appropriate resolution for poster size

API errors:

pipeline_all.py stops with "OPENROUTER_API_KEY environment variable not set" → export OPENROUTER_API_KEY=... in the same shell (it does not read .env)
"the following arguments are required: --output_dir" → use the underscore flag, not --output-dir
Verify the sub-module keys in .env (and AutoPR/.env)
Check API credit balance
Ensure no rate limiting (wait and retry)

Platform-Specific Features

Social Media Optimization

The system auto-detects target platforms:

Twitter/X (English, numeric folder names):

mkdir -p input/001_twitter/
# Generates English promotional content

Xiaohongshu/RedNote (Chinese, alphanumeric folder names):

mkdir -p input/xhs_paper/
# Generates Chinese promotional content

Conference-Specific Formatting

Specify conference requirements:

Standard poster sizes (4'×3', 5'×4', A0, A1)
Video abstract length limits (typically 3-5 minutes)
Institution branding requirements
Color scheme preferences

Integration and Deployment

Website Deployment

Deploy generated websites to:

GitHub Pages: Free hosting with custom domain
Academic hosting: University web servers
Personal servers: AWS, DigitalOcean, etc.
Netlify/Vercel: Modern hosting with CI/CD

Poster Printing

Print-ready files work with:

Professional poster printing services
University print shops
Online services (e.g., Spoonflower, VistaPrint)
Large format printers (if available)

Video Distribution

Share videos on:

YouTube: Public or unlisted for maximum reach
Institutional repositories: University video platforms
Conference platforms: Virtual conference systems
Social media: Twitter, LinkedIn, ResearchGate

Advanced Usage

Batch Processing

Process multiple papers efficiently:

# Organize papers in batch directory
for paper in paper1 paper2 paper3; do
    python pipeline_all.py \
      --input-dir input/$paper \
      --output_dir output/$paper &
done
wait

Custom Branding

Branding is not exposed as a pipeline flag. Paper2Web can discover logos automatically when the optional Google Search API keys are set; otherwise add logos, colors, and conference theming by editing the generated website files and poster sources.

Language

The AutoPR module writes English (Twitter/X) or Chinese (Xiaohongshu) promotional copy depending on the input folder name (see Platform-Specific Features). Other output languages are not a documented pipeline option — translate or edit the generated text yourself.

References and Resources

This skill includes comprehensive reference documentation:

references/installation.md: Complete installation and configuration guide
references/paper2web.md: Detailed Paper2Web documentation with all features
references/paper2video.md: Comprehensive Paper2Video guide including talking-head setup
references/paper2poster.md: Complete Paper2Poster documentation with design templates
references/usage_examples.md: Real-world examples and workflow patterns

External Resources:

GitHub Repository: https://github.com/YuhangChen1/Paper2All
Paper: Chen et al. (2025), "Paper2Web: Let's Make Your Paper Alive!", arXiv:2510.15842
Curated Dataset: Available on Hugging Face (13 research categories)
Benchmark Suite: Reference websites and evaluation metrics

Evaluation and Quality Metrics

Use these dimensions as a review checklist for generated outputs:

Content Quality

Completeness: Coverage of paper content
Accuracy: Faithful representation of findings
Clarity: Accessibility and understandability
Informativeness: Key information prominence

Design Quality

Aesthetics: Visual appeal and professionalism
Layout: Balance, hierarchy, and organization
Readability: Text legibility and figure clarity
Consistency: Uniform styling and branding

Technical Quality

Performance: Load times, responsiveness
Compatibility: Cross-browser, cross-device support
Accessibility: WCAG compliance, screen reader support
Standards: Valid HTML/CSS, print-ready PDFs

The Paper2Web paper (arXiv:2510.15842; benchmark on Hugging Face) scores generated sites on informativeness, aesthetics, QA accuracy, completeness, connectivity, and interactivity; the checklist above is broader. The pipeline does not guarantee that every output passes it, so review each output yourself.

Part of the AlterLab Academic Skills suite.

About this skill

Overview

When to Use This Skill

Does NOT Trigger

Visual Enhancement with Scientific Schematics

Core Capabilities

1. Paper2Web: Interactive Website Generation

2. Paper2Video: Presentation Video Generation

3. Paper2Poster: Conference Poster Generation

Quick Start

Prerequisites

Basic Usage

Workflow Decision Tree

Input Requirements

Supported Input Formats

Input Organization

Common Parameters

Component Selection (pipeline_all.py)

Model Selection (video pipeline)

Poster Customization (pipeline_all.py)

Output Structure

Best Practices

Input Preparation

Model Selection Strategy

Component Priority

Quality Assurance

Resource Requirements

Processing Time

Computational Requirements

API Costs

Troubleshooting

Common Issues

Platform-Specific Features

Social Media Optimization

Conference-Specific Formatting

Integration and Deployment

Website Deployment

Poster Printing

Video Distribution

Advanced Usage

Batch Processing

Custom Branding

Language

References and Resources

Evaluation and Quality Metrics

Content Quality

Design Quality

Technical Quality

Component Selection (`pipeline_all.py`)

Poster Customization (`pipeline_all.py`)