Deckyard

The open-source, end-to-end presentation platform.

Not just a slide builder: Deckyard lets you create, present, publish, and collaborate on presentations in one web-based tool that runs on infrastructure you control. Every deck stays yours, from first draft to live audience.

AI on your terms. People reach for AI to draft decks; Deckyard puts you in control of it. Bring your own API key, tune the prompts, or drive it from your own tools over Model Context Protocol (MCP). No forced LLM, no lock-in.

Built with plain Node.js and vanilla ESM. No framework, no bundler, no vendor lock-in.

Live at deckyard.eu — product site, documentation, and a sandbox to try it in the browser. Or self-host it yourself; everything below is the same engine.

Why Deckyard

For presenters: 35 typed slide types, live presenting with speaker notes, audience follow-along with polls and Q&A, a fully-translated UI in Dutch and English (plus ten more best-effort locales), and an AI wizard that actually understands presentation design.

For developers: Self-hosted, BYO LLM (OpenAI, Claude, Mistral), fully themeable, embeddable via JS SDK, white-label ready. Fork it, theme it, extend it with custom slide types. Zero cloud dependencies.

For AI agents: 27 MCP tools, 7 guided prompts, and a type-aware generation pipeline that understands the difference between a KPI dashboard and a timeline. Connect via stdio (Claude Desktop, Cursor) or SSE (remote agents, OpenClaw, webhooks). Your agent doesn't generate slide markup; it describes what it wants, and Deckyard handles the rest.

What makes it different

	Gamma / Tome / Beautiful.ai	Google Slides + Gemini	Deckyard
AI generation	✅	✅	✅ 35 typed slides
MCP interface	❌	❌	✅ 27 tools + 7 prompts
Self-hosted	❌	❌	✅
BYO LLM	❌	❌	✅
Custom themes	Limited	Limited	✅ Full control
Embed SDK	❌	Limited	✅
White-label	❌	❌	✅
Open source	❌	❌	✅ MIT

Quick Start

One command — picks Docker or Node 22+ automatically, writes a local .env, starts the app, and opens your browser:

curl -fsSL https://raw.githubusercontent.com/jaapstronks/deckyard/main/scripts/install.sh | bash

Prefer to do it by hand (or read before you pipe)? The manual path:

git clone https://github.com/jaapstronks/deckyard.git
cd deckyard
npm install
npm run setup   # optional: AI key, auth, port (Enter accepts defaults)
npm run start
# Open http://localhost:4177

The installer is scripts/install.sh; it clones the repo, writes a local .env, installs dependencies, and starts the app — nothing leaves your machine. See the self-hosting guide for the VPS/HTTPS path.

Or let your AI agent install it

Deckyard is MCP-native, so a shell-capable coding agent (Claude Code, Cursor, …) can clone it, configure it with your keys, start it, and wire itself in over MCP in one go. Paste the prompt from docs/ops/agent-install.md to your agent — it follows that same doc as a stable procedure. The non-interactive setup takes flags for exactly this: npm run setup -- --yes --ai=claude --ai-key=… --auth=off.

MCP Server — AI Agent Integration

Deckyard speaks MCP natively. Any MCP-compatible client can create, modify, and manage presentations through natural language.

Connect to Claude Desktop

{
  "mcpServers": {
    "deckyard": {
      "command": "node",
      "args": ["server/mcp/index.js"],
      "cwd": "/path/to/deckyard",
      "env": {
        "DECKYARD_MCP_OWNER_EMAIL": "you@example.com"
      }
    }
  }
}

Connect remotely (SSE transport)

For remote agents, CI/CD pipelines, or platforms like OpenClaw:

# Create an API key
node scripts/create-api-key.js --email you@example.com --name "Agent" --permissions read,write,ai

# Connect to SSE endpoint
POST https://your-deckyard.com/mcp
Authorization: Bearer dk_live_...

An installable OpenClaw skill is included — drop it in and your agent can build presentations.

What agents can do

27 tools covering the full presentation lifecycle:

• create_presentation — Generate a full deck from raw text, bullet points, or meeting notes
• iterate_presentation — Modify with natural language ("make slide 3 punchier", "split the KPI slide")
• append_slides — Add content to an existing deck (smart positioning before closing slides)
• convert_slide — Switch between 35 slide types with AI-powered content adaptation
• compress_presentation — Reduce slide count while preserving key messages
• analyze_presentation — Get suggestions for improving structure and content
• validate_presentation — Check for density issues, repetition, readability problems
• preview_slide / preview_presentation — Self-contained HTML preview for in-chat rendering
• Comments: list_comments / list_recent_comments (with slide context + snapshots), add_comment, reply_to_comment, set_comment_status — agents can triage and answer reviewer feedback
• Plus: add_slide, update_slide, remove_slide, reorder_slides, duplicate_presentation, list_themes, get_presentation_url, and more

7 guided prompts for Claude Desktop's / menu:

• /create-presentation — Guided deck creation workflow
• /create-from-structured-data — Build a deck from pre-structured slides, no AI rewriting
• /improve-presentation — Analyze and improve an existing deck
• /refine-slide — Deep-dive into a single slide
• /compress-presentation — Distill a long deck
• /add-content — Extend a deck with new material
• /deck-overview — Structural overview of any presentation

AI generation pipeline

Deckyard doesn't just dump text onto slides. The AI pipeline:

1. Outlines the deck structure, picking from 35 typed slide layouts
2. Refines each slide with type-aware content (KPI metrics, timeline entries, process steps — not just bullet points)
3. Validates the result: density checks, repetition detection, readability analysis
4. Returns reasoning for each type selection and alternative suggestions

Theme-aware: if your theme has specific brand colors or background images, the AI sees them and adapts.

Full docs: docs/reference/mcp-server.md

Customization

Deckyard is designed to be forked and branded. All customizations live in dedicated directories, so they survive an upstream merge as files. The interfaces they build on (slide-type contract, theme vars, core CSS names) are still moving while Deckyard is in beta — see docs/reference/versioning.md.

Custom Themes

Create organization-specific themes in custom/themes/:

{
  "id": "my-org",
  "label": "My Organization",
  "assets": {
    "logo": "/custom/assets/images/my-logo.svg",
    "logoAlt": "My Organization"
  },
  "cssVars": {
    "--t-color-accent": "#007bff",
    "--t-font-heading": "'Inter', sans-serif"
  }
}

See themes/amethyst.json for a complete example.

Custom Slide Types

Add organization-specific slide types in custom/slide-types/:

// custom/slide-types/my-slide-type.js
import { esc } from '../shared/slide-types/helpers.js';

export default {
  label: 'My Custom Slide',
  fields: [{ key: 'title', label: 'Title', type: 'string', required: true }],
  defaults: { title: 'New slide' },
  renderHtml: (content) => `
    <div class="slide slide-custom">
      <h1>${esc(content?.title)}</h1>
    </div>
  `,
};

Custom Assets

custom/assets/
├── images/
│   └── my-logo.svg
└── fonts/
    └── MyFont.woff2

Reference them in your theme: "/custom/assets/images/my-logo.svg"

For Forks

1. Remove the custom directories from .gitignore
2. Commit your themes, slide types, and assets
3. Set up upstream tracking:

git remote add upstream https://github.com/jaapstronks/deckyard.git
git fetch upstream --tags
git merge <newest v* tag>   # sync on release tags, not on upstream/main

Deckyard is in beta: main carries unreleased and occasionally breaking work, and a new tag is how a fork learns there is something to pull. See docs/reference/versioning.md.

Configuration

Environment Variables

Copy .env.example to .env — it documents every option. The essentials:

# AI Wizard (choose one or more)
OPENAI_API=sk-...
CLAUDE_API=sk-ant-...
MISTRAL_API=...
DEEPSEEK_API=sk-...

# Default theme (optional, defaults to 'brand')
DEFAULT_THEME=brand

# MCP owner (for stdio transport)
DECKYARD_MCP_OWNER_EMAIL=you@example.com

# Storage: PostgreSQL, configured via DATABASE_* (see the Database block in .env.example)

Authentication

Auth is disabled by default. Enable it by setting:

• AUTH_ENABLED=true
• AUTH_SECRET — A random secret for session signing
• AUTH_ADMIN_EMAIL — This user gets the admin role

Users are managed in the app itself (admin panel, invitations, password reset). For local development, AUTH_DEV_BYPASS=true skips auth entirely and auto-logs you in as admin.

Real-time collaboration (presence)

Optional and off by default — single-user installs need nothing. Set COLLAB_ENABLED=true and the server mounts a Yjs (Hocuspocus) WebSocket endpoint at /collab inside the same Node process — no extra service, port, or proxy configuration (WebSocket upgrades ride the same port; Caddy/nginx pass them through by default). With the flag on, editors show live collaborator presence: who is in the deck, which slide each person is viewing, and which field they are editing. Access control reuses the normal presentation permissions; viewers and share-link guests connect read-only. See docs/reference/collab-presence.md for how it works.

Deployment

Docker (Recommended)

# Local: app published on http://localhost:4177
docker compose -f docker-compose.yml -f docker-compose.local.yml up -d --build

# Production: app behind Caddy on 80/443 (needs DOMAIN + LETSENCRYPT_EMAIL in .env)
docker compose up -d --build

Deckyard runs on PostgreSQL, and the stack ships its own postgres:16 so the containers need no setup; pending migrations are applied automatically at container start. Point DATABASE_HOST at a managed database to use that instead.

Going from zero to a live HTTPS instance on a VPS is one command with scripts/vps-bootstrap.sh — see the self-hosting guide.

Manual

npm install --omit=dev
node server/server.js

Data Storage

Decks live in PostgreSQL: STORAGE_MODE defaults to postgres, and the compose stack ships its own database. Back up the pg_data volume (docker compose exec postgres sh -c 'pg_dump -U "$POSTGRES_USER" "$POSTGRES_DB"' > backup.sql) together with server/uploads/, which is where uploaded media stays.

The old file backend (JSON in server/data/) was removed in 1.x. An install with existing file data imports it once with npm run db:import; until then Deckyard refuses to boot on an empty database rather than show an empty workspace.

See the self-hosting guide for the storage options and .env.example for every DATABASE_* variable.

Project Structure

deckyard/
├── client/              # Frontend (browser)
├── server/              # Backend (Node.js)
│   ├── mcp/             # MCP server (stdio + SSE)
│   └── utils/ai/        # AI pipeline
├── shared/              # Shared code (slide types, markdown)
├── themes/              # Built-in themes
├── skills/              # Agent skill templates (OpenClaw)
├── custom/              # Your customizations (gitignored)
│   ├── themes/
│   ├── slide-types/
│   └── assets/
├── tests/               # MCP + unit tests
└── docs/                # Documentation

Documentation

• deckyard.eu — product site and published documentation (features, usage, guides)
• MCP Server reference — All 27 tools, 7 prompts, transport options
• Developer docs — Architecture and extending
• Theme reference — Theming system
• Self-hosting guide — VPS bootstrap, updates, backups
• ROADMAP — Where Deckyard is headed

Contributing

Contributions welcome! See CONTRIBUTING.md for guidelines.

Maintainers

Deckyard is built and maintained by Jaap Stronks. For security reports, use GitHub's private vulnerability reporting (see SECURITY.md); for everything else, open an issue.

License

MIT License — see LICENSE for details.

The deckyard.deck format specification (the deck-format reference docs) is dedicated to the public domain under CC0 1.0, separately from the MIT-licensed code, so anyone can implement the format freely — see LICENSE-spec.