# Easyslides > Use EasySlides to create, distill, edit, review, and export editable academic PPTX presentations, including 蒸馏PPT、提取模板、复用模板和答辩PPT。 Integrates SVG-to-DrawingML pipeline, XML editing, and academic design templates. Use when user asks to "create academic PPT", "make presentation", "生成PPT", "做PPT", "制作演示文稿", "thesis defense", "学术报告", "开题报告", or mentions "pptx". - Skill: `rimagination/easyslides` (Agent Skill, multi-file: 12 files) - Install (CLI): `npx skillmds@latest add rimagination/easyslides` - Raw SKILL.md: https://api.skillmd.com/api/skills/rimagination/easyslides/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: DevOps & Infra - Author: Rimagination (https://skillmd.com/u/rimagination) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/rimagination/easyslides --- # Academic PPTX Skill > Generate and edit academic/research PPTX presentations with native editable DrawingML shapes. EasySlides is a **project-backed skill**. This file is the agent entrypoint and task router; real deck generation depends on the full repository: `scripts/`, `workflows/`, `templates/`, `references/`, tests, and local runtime dependencies. Installing only `SKILL.md` is enough for routing guidance, but not enough to generate or validate PPTX files. Read `ARCHITECTURE.md` for the layer model and capability paths. Read `INSTALL.md` for minimal skill, full local runtime, and developer installation modes. ## Route Authority Before choosing an implementation path, read `workflows/routing.md`. It owns deterministic route selection for main generation, raw PPTX template fill, native PPTX enhancement, reusable template creation, slide-image reconstruction, audio, preview, and chart verification. The workflow registry is `workflows/index.md`. Before selecting a route, invoke the clarification gate in `skills/easyslides-clarify/SKILL.md`. If the request leaves more than one reasonable interpretation that would affect the route, story, page count, template, visible wording, or visual fidelity, ask the user to choose from explicit options. Do not write a deck plan or generate slide files while a blocking choice remains unanswered. ## Core Capabilities 1. **Create from scratch**: Source content → SVG pages → DrawingML shapes → editable PPTX 2. **Edit existing PPTX**: Unpack → edit XML → validate → repack 3. **HTML/JSX authoring path**: Use HTML/JSX as an experimental upstream authoring layer, then normalize into EasySlides-compatible SVG or shape IR before the existing DrawingML backend 4. **Academic scenario/template system**: Scenario-first academic planning with template-extensible output. The official template set is `academic_general`, `academic_scqa`, `defense_leftnav`, `defense_topnav`, `literature_minimal`, `nsfc_defense`, and `thu_speech`; `templates/template_policy.json` is authoritative. 5. **71 visualization templates**: Charts, infographics, diagrams, strategic frameworks, and tables 6. **11,635 icons**: Six SVG icon families for consistent academic and business visuals, with `lucide` preferred for new generic icons and emoji replacement 7. **Template Asset Bank**: Convert many real PPTX templates into exact-reuse slide modules for manual-template-substitution quality 8. **PPT Master Page Recipe Library**: whole-page SVG layout archetypes with fixed regions, text slots, diversity rules, and strict SVG slot measurement 9. **Card Component Library**: 13 fixed-size card styles plus PPT Master-style visual recipes with slot capacity contracts, agent selection rules, prompt skeletons, and PPTX preview export 10. **PPT Master compatibility mode**: Strict serial Strategist/Executor workflow, hand-written SVG pages, native DrawingML export, rebuildable backups, and gate checks via `scripts/ppt_master_pipeline.py` 11. **Native PPTX template fill route**: Raw PowerPoint templates route to `workflows/template-fill-pptx.md` instead of the SVG pipeline. 12. **Native PPTX enhancement route**: Finished decks route to `workflows/native-enhance-pptx.md` for notes/audio/timing/transition patches without visible-slide regeneration. 13. **Confirmation page**: Package deck-plan assumptions with `scripts/confirm_ui.py` before visual execution when the user wants a reviewable confirmation page. 14. **Visual review package**: Render or reuse slide PNGs through `scripts/visual_review.py` to produce a review manifest, local HTML page, and contact sheet. 15. **Brand presets**: Register reusable palette/typography/logo inputs with `scripts/create_brand.py` under `templates/brands/`. 16. **Clarification gate**: Resolve result-affecting ambiguity through explicit user choices before route selection and execution. ## Backend-Centered Architecture EasySlides has one production backend: normalized SVG/shape IR converted to editable DrawingML/PPTX by the local `scripts/svg_to_pptx/` pipeline. Multiple authoring frontends may feed that backend, but do not introduce a second production PPTX backend unless a dedicated spike proves better editable output, Office compatibility, and lower maintenance cost. ### Path A: Create from Scratch (SVG → DrawingML → PPTX) When no template PPTX exists, use the SVG-to-DrawingML pipeline: ``` Source Content → Project Init → Strategist (Deck Plan + Design Spec) → SVG Generation → Quality Check → Export PPTX ``` **Key advantage**: Every SVG element becomes an editable DrawingML shape — text is selectable, colors are changeable, shapes are movable. ### Path B: Edit Existing PPTX (XML Unpack/Edit/Repack) When a template PPTX exists: ``` Template PPTX → Unpack XML → Edit Content → Clean Orphans → Validate → Repack PPTX ``` **Key advantage**: Preserves all template formatting, animations, and layout structure. If the user asks to improve the look of an existing PPTX while preserving slide count, order, and visible wording, route through `workflows/beautify-pptx.md`. That route currently supports inspection plus a conservative native theme-color patch; stronger layout repair must not silently restructure the deck through the main generation path. ### Path C: HTML/JSX Authoring (Experimental Upstream) When the source is a rendered HTML page, dashboard, report, or SVG-heavy technical slide, use HTML/JSX only as an authoring and measurement layer: ``` HTML/JSX source -> browser measurement / component declarations -> normalized SVG or shape IR -> EasySlides validation -> DrawingML export ``` **Key advantage**: HTML/JSX is easier for LLMs to author for complex layouts, component reuse, dashboards, and architecture diagrams. The output still flows through the EasySlides checker and DrawingML backend. **Boundary**: `@artifact-kit/pptxgenjs-jsx` and `html-to-pptx-skill` may be used as references or in isolated spikes, but they are not main-path dependencies of EasySlides. Prefer integrating their DOM measurement and JSX authoring ideas upstream of the existing SVG/DrawingML backend. Use `workflows/html-jsx-authoring.md` when evaluating this path. ### Path D: PPT Master Compatibility Mode When the user explicitly asks to reproduce PPT Master, use the PPT Master workflow, or prioritize PPT Master-style SVG execution, follow `workflows/ppt-master-compat.md`. This mode keeps EasySlides' local converter stack but mirrors PPT Master's operating contract: ``` Source -> project init -> Strategist design_spec/spec_lock -> optional images -> Executor hand-writes SVG pages sequentially -> svg_quality_checker -> validate_svg_text_slots -> notes/total.md -> ppt_master_pipeline export -> editable PPTX ``` The Executor must write SVG pages directly into `svg_output/`; do not create a batch script that generates all pages. Use `references/ppt-master-compat.md` for execution rules, `templates/page_layouts/ppt-master-page-recipes-manual.md` for whole-page layout selection, and `templates/cards/assembly-manual.md` for nested card selection. For a large library of PPTX templates, prefer the Template Asset Bank harness: ``` PPTX templates → pptx_template_import.py workspaces → template_asset_bank.json → exact slide-module reuse ``` Use `workflows/template-asset-bank.md` and `scripts/template_asset_bank.py` when the goal is to mimic manual template substitution: fixed geometry, fixed decorative structure, and only text/image/chart data replaced. ### Path E: Slide Image Reconstruction When the source of truth is a slide screenshot, exported slide PNG, or AI mockup image, use `workflows/slide-image-to-editable-pptx.md`. This is an upstream analysis and QA contract for the existing EasySlides backend: first classify every visible source-image element into Layer A visual assets, Layer B native structure, or Layer C editable text; then assemble through SVG/shape IR and DrawingML export. This path explicitly forbids full-slide screenshot backgrounds, baked text in image assets, and dirty rectangular crops. Validate the Phase 1 element inventory with `scripts/slide_image_inventory.py`, then validate the final deck with `scripts/validate_image_reconstruction_pptx.py` alongside the normal text layout and render-diff gates. Use `scripts/project_manager.py init --kind slide_image_reconstruction` and `scripts/image_reconstruction_pipeline.py init/qa` as the standard project facade for this path. Default QA mode is `faithful-practical`: editable text, native structure, and split-asset safety are blocking gates, while source-vs-render pixel difference is measured and reported for inspection. Use `--mode pixel-strict` only when near-pixel source matching is required. Complex raster illustrations that become ugly as vectors should use `preserve_source_frame`; closed/circular source assets should use masked source assets with clipping checks. ### Path F: Native PPTX Template Fill When the user provides a raw PowerPoint template and asks to fill it with new material or a new topic, route to `workflows/template-fill-pptx.md`. This path preserves the source deck as a native slide library and patches cloned slides directly through OOXML. Do not convert the raw PPTX template into SVG for a one-off fill request. ### Path G: Native PPTX Enhancement When the user provides a finished PPTX and asks only for speaker notes, narration audio, auto-advance timings, or page transitions, route to `workflows/native-enhance-pptx.md`. This path is append-oriented and must not regenerate or rewrite visible slide content. ### Path H: Visual Review and Brand Presets When the user asks for a confirmation page or checklist before visual execution, route to `workflows/confirm-ui.md`. When the user asks for a visual self-check, shareable preview, or review page for an existing deck, route to `workflows/visual-review.md`. When the user asks to create, register, or inspect a reusable brand palette/logo, route to `workflows/create-brand.md`. --- ## Academic Scenario-First Template Contract Use **scenario first, template second** for academic work. In plain terms: scenario first, template second. The academic scenario defines the argument structure, evidence obligations, audience state, and page roles; the template route defines visual containers, geometry, palette, chrome, and reusable slide modules. - A **template route is not a scenario**: template route is not a scenario. Do not infer "thesis defense" just because a defense-looking template is selected, and do not infer "literature report" just because a literature-style shell is available. - The built-in scenario ids are **seed profiles** for routing, not a closed taxonomy. If the user's academic use case is not an exact match, select the nearest profile and record `scenario_variant` in `deck_plan.json` and `design_spec.md`. - Preserve the selected profile's hard and required rules, then explicitly note which recommended or relaxable rules change for the `scenario_variant`. - When no matching visual template exists, do not force a defense or literature-report template. Use free academic design, a general academic pack, a domain pack, or a user-provided template path while keeping source traceability, citation retention, text fit, and PPTX deliverability intact. - When `academic_general` or `academic_scqa` is selected, read `references/academic-orchestration.md` and apply Audience-State-Transfer plus SCQA before selecting layouts. These templates are for audience-facing academic orchestration, not developer-facing production notes. ## Source Material Policy Before planning or generating a deck, classify the user's input: - **No supplied source materials**: if the user gives only a topic, requirements, or a request to research before making the PPT, run `workflows/topic-research.md`. You may gather web text and download relevant openly licensed images as PPT assets, then import the research document and image folder as source materials with provenance. - **Provided mature source materials**: if the user supplies a journal paper, thesis/dissertation, mature report, existing deck, or similar file/URL with substantive text, figures, tables, or captions, treat that material as the source of truth. Build from its claims, structure, figures, tables, captions, and user-provided assets. Do not replace extracted figures, invent substitute evidence visuals, change the source claims, or add outside material unless the user explicitly asks; any added generic background/icon must remain decorative and never stand in for source evidence. ## Path A: Create from Scratch ### Step 1: Requirements & Project Init ```bash python scripts/project_manager.py init --format ppt169 python scripts/project_manager.py import-sources --move ``` Supported source formats: PDF, DOCX, XLSX, PPTX, URL, Markdown. **MinerU PDF Preprocessing**: When importing PDFs, the system automatically tries [MinerU](https://mineru.net) for structural extraction before falling back to PyMuPDF. MinerU provides richer output: Markdown with figure/table identification, layout JSON, and extracted images — enabling better PPTX generation with automatic figure extraction. | Method | Token Required | Output | Limits | |--------|---------------|--------|--------| | Precision Extract API | Yes (`MINERU_API_TOKEN` env or `.mineru_token` file) | Markdown + JSON + images | ≤200 MB, ≤600 pages | | Agent Lightweight API | No (IP-rate limited) | Markdown only | ≤10 MB, ≤20 pages | | PyMuPDF fallback | No | Text + images (heuristic) | None | To enable MinerU: set `MINERU_API_TOKEN` environment variable or create a `.mineru_token` file in the project root. ### Paper-Report Intake For single-paper report decks, run the paper-report intake after importing sources and before Strategist writes the final deck plan: ```bash python scripts/paper_intake.py --json ``` The intake reads `/sources/`, Markdown converted from the PDF, MinerU/PyMuPDF-side manifests when present, and `/images/`. It drafts `deck_plan.json` with a `source_map` for the main paper plus extracted figures, then validates the draft with `scripts/deck_plan_contract.py`. Strategist should treat the output as a traceable starting point: verify the paper title, figure captions, claims, and slide roles before writing the final `design_spec.md` and `spec_lock.md`. ### Single-Paper Literature-Report Flow Selection Before deriving the outline for `single_paper_report`, read `references/literature-report-flow-selection.md`. If the user provides a page outline, speaking script, learning notes, or slide-by-slide plan, that structure is the primary story contract. Preserve the user's page order and speaking logic, then use the paper/SI to verify claims and source figures. Do not replace the user's structure with an automatic long-form literature-report flow unless the user explicitly asks for a rebuild. If no outline or script is provided, choose or present two flow options: - `paper_ppt_concise`: concise, figure-first 6-10 slide paper report inspired by `xiao634zhang/paper-ppt-skill`. - `literature_report_deep_dive`: 20+ slide deep literature-report planning flow inspired by `fangyuanopus/literature-report-ppt-builder`, with `figure_source_manifest`, `deck_order_map`, and `page_briefs` before visual execution. Both options still use EasySlides' editable SVG/shape-IR -> DrawingML backend as the production path. ### Scenario Profiles and Rule Layers Before the confirmation step for academic decks, load the scenario profile catalog from `references/scenario_profiles.json`. ```bash python scripts/scenario_profiles.py --list --json python scripts/scenario_profiles.py --profile --json ``` Seed academic profiles are `single_paper_report`, `multi_paper_review`, `thesis_defense`, `proposal_or_fund`, `lab_progress`, `workshop_training`, and `conference_talk`. Pick the nearest profile from the source material, audience, and occasion, then state it as a recommendation during confirmations. If the deck is an academic scenario outside these seeds, keep the nearest profile as the rule base and record a `scenario_variant` rather than squeezing the deck into defense or literature-report wording. ### Chinese NSFC Proposal Defense When the user asks for a Chinese National Natural Science Foundation proposal defense and selects `nsfc_defense`, activate `scenario_id: nsfc_grant_cn`. This is a user-facing intent, not a request for the user to learn plan fields: the agent records the scenario contract internally and keeps the conversation in natural language. For a full deck, organize the argument as: (1) rationale and scientific question, (2) three research contents and their technical route, and (3) innovation, feasibility, and implementation plan. Every page must have one declared narrative responsibility, and the template binds that responsibility to a reviewed content variant. A table-of-contents page is optional; never add one merely because the template has a TOC shell. Ask with explicit choices before generation only when the request leaves a result-affecting decision unresolved, such as whether this is a project application or a progress defense, whether the user wants a full or concise deck, or whether supplied material may be supplemented by external research. Do not ask the user for `grant_role`, `body_variant_id`, coordinates, or other implementation details. Apply rule layers in this order: - `hard_rules`: always enforce; source faithfulness, traceability, citations, text fit, template geometry integrity, and PPTX deliverability. - `required_rules`: enforce for the selected scenario unless the user changes the scenario. - `recommended_rules`: default guidance such as action titles or ghost-deck checks; apply when useful, but let templates and content needs override. - `relaxable_rules`: soft defaults that can yield to venue, template, or teaching/activity format. Templates control visual containers; scenario profiles control content organization. Template colors, title treatment, page chrome, icon style, and layout density may override profile recommendations only when allowed by `template_may_override`; they must not override protected items in `template_must_not_override`. ### Deck Plan Contract After confirmations and before `spec_lock.md`, write `deck_plan.json` as the page-level academic story contract: ```bash python scripts/deck_plan_contract.py /deck_plan.json --json ``` Each slide entry must include `page`, `role`, `action_title`, `claim`, `evidence_sources`, `layout_id`, `rhythm`, and `speaker_note`. Use `action_title` for the page's conclusion sentence, `claim` for the supported statement, and `evidence_sources` for source-map references such as paper pages, figure/table ids, extracted images, datasets, or user-provided assets. The validated deck plan feeds `design_spec.md`, `spec_lock.md` `page_rhythm`, and later QA gates. After the deck plan passes, freeze the execution handoff as `deck_execution_lock.json`: ```bash python scripts/deck_execution_lock.py /deck_plan.json --write /deck_execution_lock.json --json ``` The execution lock records the per-page `layout_id`, `rhythm`, evidence refs, body variant selection, declared slots, template palette, and required gates. Executor must re-read `deck_execution_lock.json` together with `spec_lock.md` before each page. If either file disagrees with the current deck plan, validate with `scripts/deck_execution_lock.py --validate` and fix the plan before SVG authoring. When the selected template has `body_variants.json`, every executable content slide must use a verified body variant in `layout_id`, provide `content_shape`, and fill `slot_payload` with exactly the slots declared by that variant. The `scripts/deck_plan_contract.py` report includes `body_variant_status` from `scripts/body_variant_adapter.py`; `body_variant_contract`, `template_tokens`, `text_capacity`, `svg_quality_checker`, `preview_render`, `pptx_roundtrip`, and `visual_measure_gate` are blocking gates before SVG authoring. Do not let Executor bypass this by writing arbitrary SVG into a template body canvas. For managed template packages, compile the canonical sources before rendering: ```bash python scripts/easyslides.py template-compile templates/layouts/ --write --json python scripts/easyslides.py slide-compile /deck_plan.json --template --out /slide_ir.json --svg-out /svg --pptx-out /exports/.pptx --json ``` Treat `template_package.json`, `layouts.json`, `body_variants.json`, `component_catalog.json`, and `qa_policy.json` as owned sources. Treat `compiled/template_ir.json`, `compiled/template.lock.json`, flattened contracts, status files, and registries as generated projections. A composable body variant must bind each required component-local slot to a declared variant slot and resolve every instance to a named region or explicit placement. If several variants score equally and the user intent is unclear, block execution and ask the user to choose; do not silently pick the first variant. A template may expose `open_component_composition` for an explicitly requested arrangement, but that route accepts only registered local components inside the declared body canvas and never permits global or cross-template assets. When the selected template exposes a `LOGO` slot, resolve it from user-provided assets and source-material image folders before SVG generation. Prefer an actual institutional, laboratory, project, or paper-source logo. If no suitable logo is available, keep the template's built-in degree-cap icon fallback; when a real logo is inserted, replace the full `LOGO` group or hide the fallback drawing. ### Academic QA Gate Before SVG generation, run the Academic QA Gate on the finalized `deck_plan.json`: ```bash python scripts/academic_qa_gate.py /deck_plan.json --json ``` The gate checks the deck-plan contract plus academic expression rules: `action_title` must be a conclusion sentence rather than a topic label, result pages need figure/table/data/chart evidence, source-linked decks should include a References/source-provenance slide, and scenarios that recommend `conclusion_last` should end on Conclusions rather than a generic thank-you page. Errors block execution; warnings should be resolved or consciously accepted before writing final SVGs. For academic content, run the general clarification gate first. Then present the **Five Confirmations** (blocking) only for academic values that are still unresolved; do not repeat a value the user already selected: | # | Confirmation | Default for Academic | |---|-------------|---------------------| | 1 | Canvas format | 16:9 (1280x720) | | 2 | Page count | Based on source volume | | 3 | Target audience | Committee / peers / general | | 4 | Style objective | Mode B (data clarity) or C (logical persuasion) | | 5 | Color scheme | Academic blue `#003366` + accent `#0066CC` | After user confirms, output `deck_plan.json`, `deck_execution_lock.json`, `design_spec.md`, and `spec_lock.md`. ### Step 2: Template and Design Foundation Choose the design foundation from the confirmed scenario and template route: - If the user provides an explicit template path, inspect that template and bind the story roles to its available shells or reusable modules. - If the user asks to use an available EasySlides template, select the best matching active academic pack from `templates/layouts/`. - If no matching template exists, create a free academic design or use a general/domain academic pack; do not force a defense or literature-report template onto unrelated academic scenarios. - `academic_general` is the neutral general academic fallback when no domain or scenario-specific pack fits. - `academic_scqa` is the structured academic/technical report variant when the material benefits from visible Audience-State-Transfer and SCQA progression. The design spec must record the chosen `scenario_profile`, any `scenario_variant`, the template route, and which template constraints may override visual preferences. Use `templates/reference/design_spec_reference.md` for the required 11-section structure, then pull the selected template's `design_spec.md` only if that template is actually selected. ### Step 3: SVG Generation Generate SVG pages sequentially (one at a time). In Path A, each page is hand-written SVG. In Path C, generated SVG must be normalized to the same contract before validation and export. **Critical rules**: - viewBox must match canvas (e.g., `0 0 1280 720`) - Use `` for backgrounds, `` for text wrapping - Never use `rgba()`, `foreignObject`, ``, or `