# Presenton: a self-hosted AI presentation generator with a PPTX export API

> Presenton is an Apache-2.0 TypeScript and Python application that turns a prompt or a document into editable PowerPoint slides, running either as a Docker service or as a desktop app. The interesting part is not the slide output but the provider indirection and the API surface around it.

**presenton/presenton** — Open-Source AI Presentation Generator and API (Gamma, Canva, Beautiful AI, Decktopus, Presentations AI Alternative)

- Repository: https://github.com/presenton/presenton
- Website: https://presenton.ai
- Stars: 10,822 · Forks: 1,643
- Language: TypeScript
- License: Apache-2.0
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/presenton-presenton

## What Presenton actually replaces

The project describes itself as an open-source AI presentation generator and API, positioned against hosted tools such as Gamma, Canva, Beautiful AI and Decktopus. The practical difference is where the generation happens. Presenton is designed to run self-hosted, either through a Docker package or as a downloaded desktop app for Mac, Windows and Linux, and the README frames the motivation as avoiding SaaS lock-in and forced subscriptions. That framing matters because it tells you who the intended user is: someone who already has a model provider account and would rather not send their source documents to a third-party slide service. The README also states that it works with your own design and templates, which is the second half of the pitch. Generating a deck is easy; generating one that matches an existing corporate template is the harder problem, and Presenton addresses it by letting you convert a PPTX into an AI-ready template.

## How generation works: providers, templates and the export pipeline

The architecture visible in the repository is a split between a Next.js frontend and a FastAPI backend. The Dockerfile builds both: a python:3.11-slim-trixie stage installs the FastAPI server from servers/fastapi using uv, and a separate node:22-bookworm-slim stage builds servers/nextjs. The two are combined into a runtime image that also carries Chromium, which is why PUPPETEER_EXECUTABLE_PATH is set to /usr/bin/chromium in docker-compose.yml. That is a strong hint about the export path: rendering slides to PDF or images is done through a headless browser rather than a native office library. The image build also warms FastEmbed caches into the layer and installs the spaCy en_core_web_sm model, which the Dockerfile comments tie to mem0 and BM25 lemmatization. So there is a retrieval or memory component in the generation flow, not just a single prompt to an LLM. On the model side, Presenton does not ship a model. The compose file exposes a long list of environment variables for OpenAI, DeepSeek, Google, Vertex, Azure OpenAI and others, plus a generic LLM variable, and the README lists Ollama, LM Studio, Fireworks, Together AI, Amazon Bedrock and Anthropic among supported providers. The presentationExportVersion field in package.json is pinned separately from the app version, which suggests the export layer is versioned and synced independently through scripts/sync-presentation-export.cjs.

## Installing Presenton with Docker and generating a first deck

The repository ships a docker-compose.yml whose production service builds from the local Dockerfile by default; the image line pointing at ghcr.io/presenton/presenton:latest is present but commented out. The service maps a host port to container port 80, defaulting to 5001, and also maps port 1455, which the file annotates as required for the Codex OAuth callback because OpenAI redirects the browser directly to localhost:1455. Bring the stack up with:

```bash
docker compose up
```

After the build finishes, the web interface is reachable at http://localhost:5001 unless you override the port. The compose file reads the host port from the PRESENTON_HTTP_HOST_PORT variable, so a different port is set by exporting it before the same command:

```bash
export PRESENTON_HTTP_HOST_PORT=8080
docker compose up
```

Generation needs a model. The compose file reads provider credentials from your environment, and OPENAI_API_KEY is one of the variables it declares:

```bash
export OPENAI_API_KEY=sk-...
docker compose up
```

The compose file also declares LLM and OPENAI_MODEL, but the README does not document the accepted values for either, so treat provider selection and model choice as something to confirm against the running interface rather than something the compose file explains. Two volumes are mounted: ./app_data into /app_data, which is where generated state should persist, and ./servers/fastapi/templates mounted read-only into the container. If you want to use your own design, the README points to a custom-template flow that converts a PPTX into an AI-ready template, and the repository provides scripts/convert-template.mjs and scripts/convert-presentation-template.mjs for that conversion. The package.json scripts expose them as:

```bash
npm run convert:presentation-template
```

The README does not state the required arguments for that script, so check the script itself before relying on it.

## The beta versioning is the real adoption risk

Every recent release tag in the repository carries a beta suffix: v0.9.10-beta, electron-v0.9.10-beta and electron-v0.9.9-beta, all dated 2026-09-08. The package.json version field agrees at 0.9.10-beta. The last push to the default branch was on 2026-09-17, so the project is being worked on, but the version numbering tells you the maintainers have not declared a stable line. For a tool that produces client-facing decks, that is a meaningful constraint: you should expect interface and configuration churn between releases, and you should not build a pipeline that assumes the compose file's variable names are frozen. The second limitation is provider dependency. Presenton has no bundled model, so every generation costs you an API call to a provider you configure, and the quality of the output is bounded by that model. Self-hosting removes the SaaS subscription, not the inference cost. Third, the export pipeline depends on Chromium inside the container, which makes the image large and means the rendering environment is a browser rather than PowerPoint itself. The README promises fully editable PPTX export, but the README does not document what happens to fonts or complex master slides that the browser cannot reproduce, so test that against your own template before trusting it.

## Presenton compared with a plain PPTX templating library

The obvious alternative for programmatic deck generation is python-pptx, which manipulates the Open XML format directly. The difference in approach is fundamental. python-pptx gives you deterministic control: you write code that places a text frame at a coordinate, and it lands there every time. It has no opinion about content. Presenton inverts this. You give it a prompt or a document, a model decides what the slides say, and the template decides how they look. That is the right trade when the bottleneck is writing the content, and the wrong trade when the bottleneck is layout precision or when the deck must be byte-for-byte reproducible. A second alternative is the hosted category the README names directly, Gamma and Canva among them. Those remove the setup entirely and handle model choice for you, at the cost of sending your material to their servers and paying a subscription. Presenton's proposition only makes sense if one of those two constraints, data locality or subscription cost, actually binds you.

## Licence and the cost of keeping it running

Presenton is licensed under Apache-2.0, and the repository carries a NOTICE file alongside the LICENSE, which is the standard Apache arrangement. For most internal deployments that means you can run, modify and redistribute it, including commercially, provided you preserve the licence and notice files and state significant changes. This is not legal advice; if you plan to redistribute a modified version or embed it in a product, have counsel read the NOTICE and confirm what attribution your distribution requires. On upgrade cost, the split versioning is the thing to watch. The app version and presentationExportVersion move independently, and scripts/sync-presentation-export.cjs exists specifically to keep the export layer in step, with a --check-only mode exposed as npm run check:presentation-export. If you fork the project, that sync step becomes your responsibility. The database migration flag MIGRATE_DATABASE_ON_STARTUP defaults to true in the compose file, so schema changes apply on container start; the README does not document a rollback path if a migration fails.

## Conclusion

Adopt Presenton if you need slide generation that stays inside your own network and you are prepared to supply your own model credentials, because the docker-compose file wires up OpenAI, DeepSeek, Google, Vertex, Azure OpenAI and other providers through environment variables rather than a bundled model. Do not adopt it if you need a stable release channel: the current version string in package.json is 0.9.10-beta, and the recent tags are all beta. Before committing, verify which LLM provider you will point it at, confirm the 5001 host port and the 1455 callback port are free on your machine, and read the docker-compose volume mounts to decide where app_data and your templates directory will live.

## FAQ

### What is Presenton?

Presenton is an open-source AI presentation generator and API, licensed under Apache-2.0 and written primarily in TypeScript. It creates presentations from a prompt, an uploaded document or your own PowerPoint design, and exports editable PPTX or PDF.

### How do I install Presenton with Docker?

The repository includes a docker-compose.yml with a production service that builds from the local Dockerfile. Running docker compose up maps host port 5001 to container port 80 by default, and the interface is then served on that host port.

### Which AI providers does Presenton support?

The README lists Ollama, LM Studio, OpenAI, Gemini, Vertex AI, Azure OpenAI, Amazon Bedrock, Fireworks, Together AI, Anthropic and any other OpenAI-compatible provider. The docker-compose file exposes matching environment variables such as OPENAI_API_KEY, DEEPSEEK_API_KEY and GOOGLE_API_KEY.

### Can Presenton use my own PowerPoint template?

Yes. The README states that it works with your own design and templates, and points to a custom-template flow that converts a PPTX into an AI-ready template. The repository also includes scripts/convert-presentation-template.mjs for that conversion.

### Is Presenton stable enough for production?

The current version in package.json is 0.9.10-beta, and the recent release tags all carry a beta suffix. The last push to the default branch was on 2026-09-17. Treat configuration and interface details as subject to change between releases.

## Sources

- [License: Apache-2.0](https://github.com/presenton/presenton/blob/main/LICENSE)
- [presenton/presenton on GitHub](https://github.com/presenton/presenton)
- [Project website](https://presenton.ai)
- [README](https://github.com/presenton/presenton/blob/main/README.md)
- [Releases](https://github.com/presenton/presenton/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/presenton-presenton