Why We Built a Pure-Rust PowerPoint Engine (pptx-rs) and Open-Sourced It

We wrote a Rust engine that compiles JSON into editable PowerPoint files, then kept GenPPT visual-first and open-sourced the engine under MIT. Benchmarks against pptxgenjs, plus a timed walkthrough that turns a GenPPT image export into an editable deck.

Ilias Ism

by Ilias Ism

17 min read

Why We Built a Pure-Rust PowerPoint Engine (pptx-rs) and Open-Sourced It

We build GenPPT and open-sourced pptx-rs under the MIT license. The pptxgenjs comparison is reproducible with bench/compare-pptxgenjs.mjs in the repository. The conversion test ran on an Apple M5 Max on November 20, 2026.

GenPPT draws every slide as an image. The decks look art-directed because of it, and the exported .pptx holds one full-slide picture per slide. You can present that file. You can't click a number and change it.

We wanted editable exports, so I wrote a PowerPoint engine in Rust: a compiler, a .pptx importer, a validator, and a PNG preview renderer in one 12 MB binary. It passed every engineering check we had. Then we put its one-shot LLM layouts next to real customer decks from GenPPT's visual pipeline, and the visual decks looked better. GenPPT stays visual-first. The engine is open source as pptx-rs under the MIT license.

This post covers what the engine does, how it benchmarks against pptxgenjs, and how to turn a GenPPT image export into an editable deck with it, including a timed run on a real GenPPT slide.

Why we built pptx-rs

A coding agent that writes slides needs three things from its tooling: text that fits its box, a preview it can look at, and a file PowerPoint opens without a repair prompt. The existing options miss at least one.

pptxgenjs and python-pptx write XML without measuring text. They can't tell you a headline overflows, can't read an existing deck back into a clean schema, and can't show you a slide without LibreOffice.

LibreOffice pipelines can render, but a preview took 1.3 to 2.8 seconds in our benchmark, the container is heavy, and fonts get substituted when a customer opens the file in PowerPoint.

pptx-rs is one binary with six commands: compile, render, validate, import, mutate, and schema.

  • Text fitting with HarfBuzz (rustybuzz). The compiler shapes every text box twice, once in the chosen font and once in Arimo (metric-identical to Arial), so copy stays inside its box when PowerPoint substitutes fonts on another machine.
  • 10 Excel-backed chart types. Bar, horizontal bar, stacked bar, combo bar-line, waterfall, scatter, line, area, pie, and doughnut. Each chart embeds a real .xlsx workbook (rust_xlsxwriter), and calamine checks that the workbook matches the chart's XML cache.
  • PNG previews through resvg. About 30 ms per vector slide at 1280px, with no LibreOffice.
  • A .pptx importer. It reads text, multi-level lists, shapes, gradients, tables, charts, images, SmartArt fallbacks, and speaker notes into the same JSON the compiler takes.
  • Limits for multi-tenant servers. ZIP caps (100 MiB archive, 2,000 entries, 128 MiB inflated), XML depth and node limits, image pixel caps, and PPTX_RS_DISABLE_LOCAL_PATHS=1 to block filesystem reads.

Four-slide quarterly review rendered directly by pptx-rs

pptx-rs vs pptxgenjs

Capabilitypptx-rs (Rust)pptxgenjs (Node.js)
RuntimeOne binary (~12 MB)Node.js or browser + node_modules
PNG / SVG previewBuilt in (resvg, ~30 ms per vector slide)Needs LibreOffice + pdftoppm
Text overflow detection and auto-fitYes (HarfBuzz via rustybuzz, checked against Arimo)No (writes XML without measuring text)
.pptx to JSON importerYes (text, tables, charts, media, SmartArt)No (write-only)
OOXML and Excel parity validatorYes ([Content_Types].xml, rels, .xlsx caches)No (4.0.1 emits N - 1 dangling slideMaster <Override> entries)
Excel-backed charts10 types (rust_xlsxwriter + calamine parity check)Yes (pptx.addChart)
Fonts and script routing9 bundled TTFs, plus RTL, Turkish, Greek, and Cyrillic routingRelies on host or PowerPoint fonts
Security caps (ZIP bomb, XML depth, sandbox)Built in (PPTX_RS_DISABLE_LOCAL_PATHS=1)None built in
Authoring modelDeclarative JSON (pptx-rs schema) + Agent SkillImperative JS API

Real benchmarks

We ran pptx-rs against pptxgenjs 4.0.1 on an Apple M5 Max (darwin-arm64, Node.js v24.22.2, headless LibreOffice + pdftoppm). Both tools built identical 4-, 10-, and 25-slide decks: a cover, a 4-card KPI dashboard, a 2-series bar chart, and a styled 7x5 table. Each number is the median of 9 compile runs and 3 render runs from bench/compare-pptxgenjs.mjs.

Compile + 1280px PNG preview (what an AI coding agent waits on)

Deck Sizepptx-rs Compile + Renderpptxgenjs + LibreOffice PNGsSpeedup
4 slides148.8 ms (20.0 ms compile + 128.8 ms render)1,374.5 ms (47.4 ms + 1,327.1 ms)9.2x faster
10 slides355.0 ms (42.3 ms compile + 312.7 ms render)1,868.2 ms (54.5 ms + 1,813.7 ms)5.3x faster
25 slides849.5 ms (109.7 ms compile + 739.8 ms render)2,888.9 ms (64.4 ms + 2,824.5 ms)3.4x faster

Compile time, file size, and OOXML validation

Metric4 Slides10 Slides25 Slides
pptx-rs cold CLI (compile + HarfBuzz fit + validate)20.0 ms (17 ms internal)42.3 ms (38 ms internal)109.7 ms (104 ms internal)
pptxgenjs cold CLI (Node startup + write, no shaping or validation)47.4 ms54.5 ms64.4 ms
pptxgenjs warm in-process (XML emit only)4.2 ms6.6 ms13.8 ms
.pptx file size (pptx-rs vs pptxgenjs)28.7 KB vs 154.3 KB (5.4x smaller)57.8 KB vs 296.9 KB (5.1x smaller)139.6 KB vs 737.7 KB (5.3x smaller)
pptx-rs validate errors (pptx-rs vs pptxgenjs)0 vs 3 dangling slideMaster overrides0 vs 9 dangling slideMaster overrides0 vs 24 dangling slideMaster overrides

pptxgenjs wins one row. In a warm Node process it emits XML in 4 to 14 ms, because it skips font shaping, validation, and previews. pptx-rs spends 17 to 104 ms shaping every text run twice, writing .xlsx workbooks, and validating each XML part and chart cache. The preview step is where the time goes for an agent: LibreOffice needs 1.3 to 2.8 seconds, and pptx-rs needs 129 to 740 ms.

Why we kept visual-first slides in GenPPT

We fed real customer prompts to a single-shot LLM that authored raw { x, y, w, h } coordinates. The output was valid, editable, and typo-free. It was also plainer than what GenPPT already made: no custom illustrations, no brand marks, and template cards that all looked alike.

That drew the line for us:

  • Hosted decks stay in GenPPT. People pay for GenPPT because the slides look designed. Browse real output on the GenPPT showcase, or see how it scores against Gamma, Plus AI, Canva, and Copilot in our 2026 AI presentation maker benchmark.
  • Agent-built and programmatic decks go to pptx-rs. Claude Code, Cursor, or Codex with a terminal can compile, render, look at every PNG, and fix spacing in a loop that takes about 150 ms per pass. The look-and-fix passes are what close the gap that a one-shot layout leaves.

The two also combine, which is the rest of this post.

How to convert GenPPT slide images into an editable .pptx

A GenPPT deck exports three ways from the Export menu: PDF (.pdf), PowerPoint (.pptx), and Images (.zip). Exporting needs an active plan or the $1 three-day trial.

The PowerPoint export is one full-slide image per slide. That's the right file when you only need to present. When someone has to edit a number in PowerPoint or open a chart in Excel, start from the image export and rebuild the slides that need it.

What the Images (.zip) export gives you

The ZIP holds the stored slide images at full resolution, with no re-encoding, named by slide number:

text
genppt-slides/
  slide-01.png
  slide-02.png
  slide-03.png
  ...

The extension follows the stored format, so a deck can also contain .jpg or .webp files. pptx-rs embeds PNG and JPEG as they are and converts WebP to PNG.

Unzip the export next to where your deck JSON will live:

Bash
unzip your-deck-images.zip -d genppt-slides

Then build pptx-rs (Rust 1.89 or newer) and put it on your PATH:

Bash
git clone https://github.com/Illyism/pptx-rs.git
cd pptx-rs
cargo build --release
export PATH="$PWD/target/release:$PATH"

Workflow A: keep the artwork, make the content editable

A GenPPT slide has two layers baked into one picture: artwork you want to keep and content someone will want to change. In deck.ir.json you split them again.

  • plate places an image full-bleed or framed. With "scrim": "auto", the compiler reads the pixels behind each text box and adds a gradient only where contrast falls below WCAG AA (4.5:1).
  • cutout places a cropped or masked piece of an image (circle, roundRect, arch, diamond), with an optional border and shadow.
  • srcRect crops either one. It takes [left, top, right, bottom] as fractions to trim from each edge, so you can cut the artwork out of a slide and leave its baked-in text behind.
  • text, table, and chart go on top as native PowerPoint objects.

For the test I took the 11-slide Product-Led Growth deck from the GenPPT homepage. Slide 1 has a 3D funnel on the right and the title on the left. Slide 6 is a metrics framework with five targets. The JSON below rebuilds both: the funnel becomes a plate under an editable title, and the five targets become a native table and an Excel-backed chart, with the funnel repeated as a small circular cutout.

JSON
{
  "irVersion": 1,
  "title": "Product-Led Growth Strategy",
  "theme": {
    "aspectRatio": "16:9",
    "bg": "#F4F5FA",
    "surface": "#FFFFFF",
    "fg": "#0B1437",
    "muted": "#5B6478",
    "accent": "#4F46E5",
    "accentSecondary": "#22B8CF",
    "fontDisplay": "Plus Jakarta Sans",
    "fontBody": "Inter"
  },
  "slides": [
    {
      "background": "#0B1437",
      "elements": [
        {
          "name": "Funnel art from slide-01",
          "type": "plate",
          "rect": { "x": 0, "y": 0, "w": 100, "h": 100 },
          "zIndex": 0,
          "source": { "path": "genppt-slides/slide-01.png" },
          "srcRect": [0.46, 0.14, 0, 0.32],
          "scrim": "auto",
          "scrimColor": "#0B1437"
        },
        {
          "name": "Cover headline",
          "type": "text",
          "rect": { "x": 6, "y": 52, "w": 52, "h": 26 },
          "zIndex": 2,
          "text": "Product-Led\nGrowth Strategy",
          "role": "display",
          "sizePt": 48,
          "minSizePt": 36,
          "bold": true,
          "color": "#FFFFFF",
          "lineHeight": 1.08
        },
        {
          "name": "Cover subtitle",
          "type": "text",
          "rect": { "x": 6, "y": 78, "w": 50, "h": 13 },
          "zIndex": 2,
          "text": "Build a scalable PLG engine that acquires, activates, and expands customers through the product.",
          "sizePt": 16,
          "color": "#E2E8F0",
          "lineHeight": 1.35
        }
      ]
    },
    {
      "background": "#F4F5FA",
      "elements": [
        {
          "name": "Slide title",
          "type": "text",
          "rect": { "x": 5, "y": 6, "w": 70, "h": 10 },
          "zIndex": 2,
          "text": "PLG Metrics Framework",
          "role": "display",
          "sizePt": 32,
          "bold": true
        },
        {
          "name": "Slide subtitle",
          "type": "text",
          "rect": { "x": 5, "y": 16, "w": 70, "h": 6 },
          "zIndex": 2,
          "text": "Define the core KPI suite and target benchmarks across the user lifecycle.",
          "sizePt": 15,
          "color": "#5B6478"
        },
        {
          "name": "Funnel cutout from slide-01",
          "type": "cutout",
          "rect": { "x": 84, "y": 5, "w": 10.5, "h": 18.7 },
          "zIndex": 2,
          "source": { "path": "genppt-slides/slide-01.png" },
          "srcRect": [0.545, 0.16, 0.103, 0.21],
          "clipShape": "circle",
          "borderColor": "#FFFFFF",
          "borderWidthPt": 2,
          "shadow": { "blurPt": 14, "distPt": 4, "color": "#0B143722" }
        },
        {
          "name": "Metrics table",
          "type": "table",
          "rect": { "x": 5, "y": 27, "w": 52, "h": 56 },
          "zIndex": 2,
          "headers": ["Metric", "Target", "Definition"],
          "rows": [
            ["Activation Rate", "≥ 40%", "Users who experience the core value"],
            ["Time-to-Value", "≤ 5 min", "Median time to first win"],
            ["Retention Baseline", "≥ 25%", "Week 4 retention (minimum)"],
            ["Expansion Index", "≥ 1.3x", "Net revenue expansion from existing users"],
            ["Trial-to-Paid Conversion", "≥ 15%", "Trials converting to paid accounts"]
          ],
          "columnWeights": [1.9, 0.8, 2.2],
          "columnAligns": ["left", "right", "left"],
          "fontSizePt": 13,
          "headerBg": "#0B1437",
          "headerFg": "#FFFFFF",
          "rowBg": "#FFFFFF",
          "altRowBg": "#EEF0F8",
          "borderColor": "#D5D9E6"
        },
        {
          "name": "Targets chart",
          "type": "chart",
          "chartType": "horizontalBar",
          "rect": { "x": 60, "y": 27, "w": 35, "h": 56 },
          "zIndex": 2,
          "title": "Percentage targets",
          "categories": ["Activation Rate", "Retention Baseline", "Trial-to-Paid"],
          "series": [{ "name": "Target", "values": [0.4, 0.25, 0.15], "color": "#4F46E5" }],
          "numberFormat": "0%",
          "showDataLabels": true
        },
        {
          "name": "Footnote",
          "type": "text",
          "rect": { "x": 5, "y": 86, "w": 90, "h": 5 },
          "zIndex": 2,
          "text": "Benchmarks vary by stage and segment. Review monthly.",
          "sizePt": 10,
          "color": "#5B6478"
        }
      ]
    }
  ]
}

Three details in that file matter when you write your own:

  1. Coordinates are percentages of the slide, and image paths resolve from the directory you run pptx-rs in.
  2. A full-bleed srcRect crop must keep the slide's aspect ratio. The plate trims 46% from the left and 46% from top and bottom combined, so the remaining 54% by 54% is still 16:9 and nothing stretches. The cutout keeps a square of pixels for its circular mask.
  3. Every number in the table and chart comes from the source slide. Nothing in a rebuilt deck should be retyped from memory.

Compile, render, and validate:

Bash
pptx-rs compile -i deck.ir.json -o deck.pptx --report compile-report.json
pptx-rs render -i deck.ir.json --out-dir previews --width 1280 --report render-report.json
pptx-rs validate deck.pptx

The timed test run

Same machine as the benchmarks above (Apple M5 Max), pptx-rs 0.1.0. The homepage copies of the slides are 1376x768 JPGs, so I converted them to PNG first to match the ZIP naming.

text
$ pptx-rs compile -i deck.ir.json -o deck.pptx --report compile-report.json
Compiled 2 slides (1 charts, 1 media, 1 scrims) in 20ms -> deck.pptx

$ pptx-rs render -i deck.ir.json --out-dir previews --width 1280 --report render-report.json
Rendered 2 slide(s) in 160ms -> previews

$ pptx-rs validate deck.pptx
Validated 'deck.pptx': 22 parts, 20 XML parts, 19 rels, 2 slides, 1 Excel-backed charts
PASS: 0 errors.

The top of compile-report.json:

JSON
{
  "slideCount": 2,
  "chartCount": 1,
  "mediaCount": 1,
  "scrimsInserted": 1,
  "compileMs": 20
}
MeasurementResult
compileMs over 9 runs20 to 21 ms
compile wall clock, median of 15 runs24.7 ms
renderMs for two 1280px PNGs, 5 runs155 to 158 ms
render wall clock, median of 15 runs162.5 ms
validate wall clock, median of 15 runs2.5 ms
deck.pptx size607,971 bytes
Embedded slide-01.png590,657 bytes
Text boxes with overflowWarning0 of 5
scrimsInserted1
Validator errors0

What those numbers say:

  • One scrim, on the cover. White text over a pale plate fails 4.5:1, so the compiler added a left-to-right gradient in the scrim color that starts at 72% opacity and fades to 0. Slide 2 has no plate under its text and got none.
  • One media part for two uses. The plate and the cutout reference the same PNG. The archive stores it once.
  • The file is 97% image. The slide XML, chart, and embedded Excel workbook add about 17 KB on top of the PNG. Compiling the same JSON against the original 96 KB JPEG of that slide produced a 113,548-byte deck.
  • Image slides render slower than vector slides. Two slides took about 157 ms here, against about 30 ms per slide for the vector deck in the benchmarks. The cover decodes and scales a full-resolution PNG.

Two source GenPPT slides on top, and the editable pptx-rs rebuild rendered below them

The top row is the GenPPT source. The bottom row is pptx-rs render output from the JSON above.

The first render caught a real bug in my JSON. I had written the chart values as [40, 25, 15] with the number format 0"%", and the preview labelled the first bar 4000%. Switching to fractions ([0.4, 0.25, 0.15]) with the Excel format 0% fixed it. The compile had passed both times. Only the PNG showed the problem, which is why the render step is in the loop.

Look at the bottom-right slide again. It is editable, correct, and plainer than the GenPPT original above it. That trade is the reason GenPPT stays visual-first, and the reason to convert only the slides someone needs to edit.

Workflow B: have a coding agent rebuild the whole deck

Doing this by hand for 2 slides is fine. For 20, give the job to an agent that can read images and run a terminal. Install the skill in your project:

Bash
npx skills add Illyism/pptx-rs

Then paste this prompt into Claude Code, Cursor, or Codex, in the folder that contains genppt-slides/:

text
Rebuild the deck in ./genppt-slides/ as an editable PowerPoint file using the pptx-rs skill.

1. Open every image in ./genppt-slides/ (slide-01, slide-02, ...) and list what each slide
   contains: headline, body copy, numbers, tables, charts, and artwork.
2. Write deck.ir.json (SlideDeckIr v1, run `pptx-rs schema` for field names) with one slide
   per image, in the same order.
   - Transcribe copy and numbers exactly as they appear. Do not round, reword, or fill gaps.
     If a number is unreadable, stop and ask me.
   - Rebuild text as `text` or `list`, tables as `table`, and any chart with 3 or more data
     points as a native `chart` with the exact values.
   - Keep illustrations, photos, and 3D artwork by referencing the source image as a `plate`
     or `cutout` with a `srcRect` crop that excludes baked-in text. Use "scrim": "auto" on
     any plate that sits under text.
   - Use only the fonts bundled with pptx-rs.
3. Run:
   pptx-rs compile -i deck.ir.json -o deck.pptx --report compile-report.json
   pptx-rs render -i deck.ir.json --out-dir previews --width 1280
4. Fix every text box in compile-report.json with overflowWarning true or missingGlyphs
   above 0.
5. Open each previews/slide-N.png next to the matching ./genppt-slides/ image. Compare
   layout, spacing, hierarchy, and every number. Fix deck.ir.json and repeat steps 3 to 5
   until each slide matches its source and no text is clipped.
6. Run `pptx-rs validate deck.pptx` and report: slides rebuilt, charts created, plates and
   cutouts used, and anything you could not reproduce.

Three rules in that prompt do most of the work. Transcribe, don't paraphrase: the deck's numbers were approved once and should survive the rebuild unchanged. Crop artwork instead of redrawing it, because the art direction is what you paid GenPPT for. And compare previews against the source images on every pass, since a compile that succeeds tells you nothing about how the slide looks.

A full pass of compile and render stayed under 200 ms in my test, so the agent's time goes to reading images and editing JSON. The tooling adds almost nothing.

When to convert and when to skip it

Convert when someone downstream has to change the content:

  • Executive decks and board updates, where finance corrects a figure the night before.
  • Client QBRs, where the account team swaps in next quarter's numbers and the client wants the chart data in Excel.
  • Investor decks, where metrics move every week of the raise.
  • Templates that a team will reuse with new copy.

Skip it when the picture is the product:

  • Social carousels for LinkedIn, X, Instagram, or TikTok. They ship as images anyway, so the ZIP is already the final format.
  • Decks built on custom illustration, where the artwork fills the slide and there's little text to edit. A rebuilt version loses what made it good.
  • Present-once decks. GenPPT's own .pptx or PDF export opens in PowerPoint, Google Slides, and Keynote and looks exactly like the slides you approved.

Most real decks split. Keep the cover, section dividers, and illustration-heavy slides as plates, and rebuild the data slides as native objects.

Pairing pptx-rs with GenPPT MCP

You can skip the ZIP and let the agent talk to GenPPT directly. The repo ships two Agent Skills, and one command installs both:

Bash
npx skills add Illyism/pptx-rs
  • pptx-rs (SKILL.md) teaches Claude Code, Cursor, or Codex the local loop: write JSON, compile, render, inspect, fix.
  • pptx-rs-genppt (skills/pptx-rs-genppt/SKILL.md) pairs that loop with the remote GenPPT MCP server (https://genppt.com/mcp) in two directions:
    1. Art in, editable deck out. The agent asks GenPPT for 1 to 3 text-free background plates or cover illustrations, then layers editable text, tables, and Excel charts over them in pptx-rs, with automatic contrast scrims.
    2. Old deck in, redesign out. pptx-rs import extracts the copy, numbers, tables, and images from an existing PowerPoint file into JSON, and the agent sends those exact metrics to genppt_create_slideshow for a visual upgrade.

Clone the engine at github.com/Illyism/pptx-rs. Build art-directed decks and social slideshows in GenPPT ($1 three-day trial, then $25/mo or $99/yr) or through genppt.com/mcp.

Ilias Ism
Ilias Ism

SEO strategist and former CTO who builds scalable content systems. Founded LinkDR, MagicSpace SEO, AISEOTracker, and GenPPT.

  • Built and sold Officient ($500k+ MRR)
  • Scaled 20+ products generating $10M+ revenue
  • 4x B2B SaaS founder
Create deck
AI presentations

Stop stressing over formatting. Join 100,000+ professionals creating presentations worth presenting.