OpenDCAI/Paper2Any: Turn Research Papers Into Editable Diagrams and Slides

Research papers are information-dense, but their visual outputs—architecture diagrams, experimental plots, technical roadmaps—are typically locked in static PDFs. Reusing or adapting these assets for presentations, proposals, or documentation means hours of manual redrawing in PowerPoint, Draw.io, or Python^{↗ Bright Coding Blog} visualization libraries. For researchers, engineers, and technical writers who need to move fast, this friction is a recurring bottleneck.

Paper2Any is an open-source Python toolkit from the OpenDCAI team that addresses this directly: it ingests paper PDFs, screenshots, or plain text and generates editable scientific figures, technical route diagrams, and presentation slides. With 2,703 GitHub stars, 189 forks, and an active commit history (last updated June 17, 2026), it has gained traction among developers who need programmatic, reproducible workflows for research communication. This article breaks down what Paper2Any does, how it works, and how to deploy it.

What is OpenDCAI/Paper2Any?

Paper2Any is a multimodal workflow engine built in Python 3.11+ and licensed under Apache 2.0. It is not a single-purpose converter but a collection of specialized sub-workflows—Paper2Figure, Paper2Diagram, Paper2PPT, PDF2PPT, and others—unified under a FastAPI backend and a React^{↗ Bright Coding Blog}-based frontend.

The project sits at the intersection of document intelligence, generative AI, and visualization automation. It leverages large language models and vision-language models for structure extraction and content generation, then renders outputs into editable formats: PPTX, SVG, Draw.io XML, PNG, and HTML-based presentations. The backend supports dynamic model selection (GPT-4o, Qwen-VL, and others via API parameters), eliminating hardcoded provider dependencies.

Notably, the maintainers distinguish between the open-source codebase in this repository and the hosted Paper to Any Studio / Nexus commercial experience. The open-source release includes the core generation pipelines, CLI scripts, and web interface—sufficient for self-hosted deployments and custom integrations.

The project has also produced peer-reviewed research: two 2026 papers, Paper2SysArch (CVPR 2026 Findings) and SciFlow-Bench (ACL 2026 Main), which validate the underlying structure-aware diagram generation methodology.

Key Features

Paper2Any's capabilities are organized into workflow modules, each targeting a specific output format:

Paper2Figure generates three types of editable scientific figures: model architecture diagrams (as PPTX or SVG), technical roadmaps with configurable visual templates, and experimental plots in multiple styles. The output is natively editable— not raster images but structured objects.

Paper2Diagram / Image2Drawio converts paper figures, screenshots, or text descriptions into Draw.io-compatible diagrams. Users can refine generated diagrams through a chat interface and export to Draw.io XML, PNG, or SVG.

Paper2PPT produces editable slide decks from papers, long documents, or topics. It includes AI-assisted outline editing, canvas-based slide editing with theme locking, table/figure extraction, and version history. HTML-based editable PPTX export and ONLYOFFICE integration are available as optional layers.

PDF2PPT and Image2PPT focus on layout-preserving conversion. PDF2PPT uses smart cutout and segmentation (via SAM3) to retain original layouts in editable PPTX. Image2PPT converts screenshots or diagrams into structured slides.

PPTPolish applies AI-based layout optimization and style transfer to existing presentations, with optional reference-image guidance for visual consistency.

Knowledge Base (KB) supports document ingestion, embedding-based semantic search, and KB-driven generation of PPTs, podcasts, and mind maps.

Additional modules include Paper2Video (video scripts and narration), Paper2Poster (academic poster layouts), Paper2Rebuttal (structured rebuttal drafting), Paper2Citation (citation network exploration), and an Image Model Playground for batch image generation with managed backends.

Use Cases

Accelerating research communication. A machine learning researcher submits a paper to a conference and needs a technical roadmap slide for the rebuttal phase. Paper2Figure's tech_route graph type generates a structured dual-column layout from the PDF in minutes, editable in PowerPoint.

Converting legacy presentations. A team has hundreds of PDF slide decks from past projects. PDF2PPT with SAM3 segmentation preserves layouts while producing editable PPTX files, enabling bulk migration to a modern template system.

Creating teaching materials from papers. An instructor preparing a course on transformer architectures uses Paper2PPT to generate a 15-slide deck from a seminal paper, then refines the outline via the AI-assisted panel and locks the theme for consistency.

Diagramming from screenshots. A developer finds a system architecture figure in a paper and needs to adapt it for documentation. Image2Drawio converts the screenshot to an editable Draw.io canvas, preserving structure while allowing modifications.

Batch image generation for papers. A research group needs consistent figure styles across multiple submissions. The Image Model Playground supports batch generation (1/2/4/8/16 images) with compressed previews and one-click download, using backend-managed models like Nano Banana 2 and Image 2.

Installation & Setup

Paper2Any supports Docker^{↗ Bright Coding Blog} deployment (recommended), Linux native installation, and Windows/WSL. The Docker path is the fastest for production-like deployments.

Docker (Recommended)

# 1. Clone repository
git clone https://github.com/OpenDCAI/Paper2Any.git
cd Paper2Any

# 2. Configure environment variables
cp fastapi_app/.env.simple.example fastapi_app/.env
cp frontend-workflow/.env.simple.example frontend-workflow/.env
cp deploy/docker.env.example deploy/docker.env

Edit fastapi_app/.env with your API keys and endpoints:

# Required: internal API auth (must match frontend VITE_API_KEY)
BACKEND_API_KEY=your-backend-api-key

# Recommended: simple mode lets backend own model choices
APP_BILLING_MODE=free
PAPER2ANY_CONFIG_MODE=simple

# Required: unified text LLM entry
SIMPLE_TEXT_API_URL=https://your-text-gateway/v1
SIMPLE_TEXT_API_KEY=your_text_key

# Optional but recommended: unified image entry
SIMPLE_IMAGE_API_URL=https://your-image-gateway
SIMPLE_IMAGE_API_KEY=your_image_key

# Optional: DrawIO OCR/VLM service
SIMPLE_OCR_API_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
SIMPLE_OCR_API_KEY=your_dashscope_key

# Optional: MinerU official remote API for PDF parsing
MINERU_API_BASE_URL=https://mineru.net/api/v4
MINERU_API_KEY=your_mineru_api_key

# Optional: SAM3 segmentation for PDF2PPT/Image2PPT/Image2Drawio
# SAM3_SERVER_URLS=http://GPU_MACHINE_IP:8001

Frontend .env:

# Must match BACKEND_API_KEY
VITE_API_KEY=your-backend-api-key

# Leave empty in Docker; nginx proxies /api and /outputs
VITE_API_BASE_URL=

# Display defaults only; backend controls actual model selection
VITE_DEFAULT_LLM_API_URL=https://your-text-gateway/v1
VITE_DEFAULT_LLM_MODEL=gpt-4o

Build and run:

bash deploy/docker-up.sh

Access points:

• Frontend: http://localhost:3000
• Backend health: http://localhost:8000/health

For SAM3-dependent workflows (PDF2PPT, Image2PPT, Image2Drawio), either point to an external SAM3 service or enable the local container:

DOCKER_WITH_SAM3=1 bash deploy/docker-up.sh

Linux Native (Conda)

conda create -n paper2any python=3.11 -y
conda activate paper2any
git clone https://github.com/OpenDCAI/Paper2Any.git
cd Paper2Any
pip install -r requirements-base.txt
pip install -e .
pip install -r requirements-paper.txt
pip install -r requirements-cu12.txt  # Linux + CUDA 12 only
conda install -c conda-forge tectonic -y
pip install doclayout_yolo --no-deps
sudo apt-get update
sudo apt-get install -y ffmpeg inkscape libreoffice poppler-utils wkhtmltopdf

Set environment variables:

export DF_API_KEY=your_api_key_here
export DF_API_URL=xxx  # Optional: third-party API gateway
export MINERU_DEVICES="0,1,2,3"  # Optional: MinerU GPU pool

Launch with the recommended entrypoint:

bash deploy/start_nv.sh

Real Code Examples

Paper2Any provides standalone CLI scripts that execute workflows without requiring the web frontend. These are useful for automation, CI pipelines, or headless servers.

Generate a Model Architecture Diagram

# Paper2Figure CLI: model architecture from PDF
python script/run_paper2figure_cli.py \
  --input paper.pdf \
  --graph-type model_arch \
  --api-key sk-xxx

This invokes the model_arch workflow, which parses the PDF, extracts structural relationships between components, and renders an editable architecture diagram. The --graph-type parameter also accepts tech_route for technical roadmaps and exp_data for experimental plots.

Convert a Paper to Presentation Slides

# Paper2PPT CLI: basic usage with custom style
python script/run_paper2ppt_cli.py \
  --input paper.pdf \
  --api-key sk-xxx \
  --page-count 15 \
  --style "Academic style; English; Modern design" \
  --language en

The CLI supports long-document handling, table/figure extraction, and style specification. Output defaults to outputs/cli/run_paper2ppt_cli/{timestamp}/.

Layout-Preserving PDF to PPTX

# PDF2PPT CLI: with AI enhancement for content refinement
python script/run_pdf2ppt_cli.py \
  --input slides.pdf \
  --use-ai-edit \
  --api-key sk-xxx

Without --use-ai-edit, the conversion preserves visual layout without LLM-based content modification. With the flag, the pipeline generates descriptive text for detected regions, improving accessibility and editability.

Beautify an Existing Presentation

# PPT2Polish CLI: style transfer with reference image
python script/run_ppt2polish_cli.py \
  --input old_presentation.pptx \
  --style "Modern minimalist style" \
  --ref-img reference_style.png \
  --api-key sk-xxx

The --ref-img parameter enables visual style consistency by extracting color palettes and layout proportions from a reference image. This requires LibreOffice, pdf2image, and poppler-utils installed system-wide.

All CLI scripts share common options:

• --api-url URL — override LLM endpoint
• --model NAME — specify text model
• --output-dir DIR — custom output directory
• --help — full parameter documentation

Advanced Usage & Best Practices

Model selection strategy. The PAPER2ANY_CONFIG_MODE=simple setting delegates all workflow model choices to backend environment variables. For fine-grained control—different models for PPT generation versus figure generation—switch to advanced mode and configure per-workflow overrides in fastapi_app/.env.

GPU resource planning. Paper2PPT, Paper2Figure, and Knowledge Base workflows require only LLM APIs and work on CPU-only deployments. PDF2PPT, Image2PPT, and Image2Drawio require SAM3 segmentation, which needs GPU access. In multi-GPU environments, use script/start_model_servers.sh to launch load-balanced MinerU and SAM3 instances across available cards.

ONLYOFFICE integration for collaborative editing. The HTML-based editable PPTX export opens in ONLYOFFICE Document Server for browser-based editing. For local development, start the server with JWT disabled and configure backend environment variables pointing to host.docker.internal.

Supabase for multi-user deployments. Authentication, cloud storage, points management, and history require Supabase configuration. Core features function without it, making single-user or air-gapped deployments viable.

Windows limitations. Native Windows support exists but is secondary to Linux/WSL. The maintainers explicitly recommend WSL for Windows users. Key dependencies like vLLM require manually downloaded wheels matched to Python version and CUDA driver.

Comparison with Alternatives

Paper2Any's distinction is structured, repeatable, editable output generation rather than raw text extraction. Nougat and Marker excel at producing clean Markdown for RAG pipelines or reading interfaces. Paper2Any targets the downstream communication layer: presentations, posters, diagrams, and videos that researchers actually present and publish.

For teams already using LLM APIs directly, Paper2Any offers value through its prompt engineering, rendering pipelines, and format-specific exporters—components that would require substantial in-house development to replicate.

FAQ

Does Paper2Any work offline? Partially. Core workflows require LLM API access. Local model inference via vLLM is possible but requires additional setup not fully documented in the open-source README.

What Python version is required? Python 3.11+ for Linux; Python 3.12 for Windows native installations.

Is the online demo the same as the open-source code? No. The hosted Studio at paper2any-studio.cpolar.cn is a commercial superset. The repository contains the open-source engine.

Can I use my own API keys? Yes. The simple configuration mode accepts any OpenAI-compatible text and image API endpoints.

What license applies? Apache License 2.0, permitting commercial use with attribution.

Is GPU required? Only for SAM3-dependent workflows (PDF2PPT, Image2PPT, Image2Drawio). Paper2PPT and Paper2Figure work with API-only LLM access.

How do I update after cloning? git pull followed by bash deploy/docker-up.sh for Docker deployments.

Conclusion

Paper2Any is a practical, engineering-focused toolkit for researchers and technical teams who need to convert static paper content into editable, presentation-ready assets. Its modular architecture—14 distinct workflows at last count—allows selective adoption without committing to a monolithic platform. The Apache 2.0 license, active development, and peer-reviewed research foundation provide credible backing for production use.

The tool is best suited for:

• Research groups producing frequent presentations and posters
• ML engineers documenting architectures and experimental results
• Technical writers migrating academic content to industry formats
• Teams with existing LLM API access seeking structured output pipelines

For developers evaluating document-to-asset pipelines, Paper2Any offers a self-hostable, code-first alternative to proprietary tools and ad-hoc scripting. The CLI interface enables automation; the web frontend supports interactive refinement.

Explore the repository, try the Docker deployment, and assess whether its workflow modules fit your research communication stack: https://github.com/OpenDCAI/Paper2Any