MarpUI for iPadOS and macOS

A native iPadOS and macOS app for creating, editing, and presenting Marp markdown slide decks.
Built with Swift and SwiftUI.

---

MarpUI brings the full power of Marp presentations to your iPad with a touch-optimised editor, live slide preview, and professional presentation modes including external display support.

Features

Editor

• Split-pane layout with markdown editor and live slide preview: side by side in a wide window, slide above the text in a tall one such as an iPad held upright
• Syntax highlighting for Marp markdown
• Slide strip showing a live thumbnail of every slide, with drag-to-reorder
• Insert menus for headings, formatting, lists, blockquotes, code blocks, tables, and more
• Image insertion from Photos with sizing, filters, and background modes
• Custom font selection per slide or entire deck
• Keyboard shortcuts and menu bar commands: ⌘B bold, ⌘I italic, ⌘S save, ⇧⌘N new presentation, ⌥⌘N new document, ⇧⌘↩ add slide, ⌥⌘P play slideshow, ⇧⌘P presenter view
• System toolbar drawn as Liquid Glass, with a title menu for rename, save and export
• Configurable auto-save, font size, tab/spaces indentation, and word wrap

Markdown Extensions

• Subscript (H~2~O) and superscript (X^2^)
• Highlights (==text==), strikethrough (~~text~~), insertion (++text++)
• Footnotes, definition lists, abbreviations
• Task lists with checkboxes
• GitHub-style alerts (NOTE, TIP, IMPORTANT, WARNING, CAUTION)
• Mermaid diagrams (flowcharts, sequence diagrams, gantt charts)
• KaTeX math (inline $E=mc^2$ and block $$...$$)
• Syntax highlighting for 190+ languages

Themes

• Built-in Marp themes: default, gaia, uncover
• Import custom CSS themes with /* @theme name */ directive
• Live theme editor with preview
• Quick theme switcher in the toolbar
• Theme fonts automatically detected and available in font menus

Theme management — built-in and custom themes

Presentation Modes

• Fullscreen Slideshow — tap, swipe, or use arrow keys to navigate
• Presenter View — current slide, next slide preview, speaker notes, and timer with pause/reset
• External Display — connect a USB-C HDMI adapter to show slides on a monitor while the iPad shows presenter view
• Keyboard navigation: arrows, space, escape

Presenter view — current slide, next slide, speaker notes, and timer

Export

• HTML — self-contained interactive slideshow with embedded images
• PDF — slide-per-page document via the share sheet

Storage & Sync

• Link your existing iCloud Drive Documents/MarpUI folder to sync decks with the MarpUI web app
• Per-deck directories keep images alongside markdown
• Visible in the Files app
• Import .md files from any source
• Conflict detection when files change on another device

Accessibility

• VoiceOver names and roles for every control, announcements for slide changes while presenting, and headings in Help and onboarding
• Follows the system text size, including in the code editor and the document preview, with layouts that hold up at the accessibility sizes
• Text and control contrast of at least 4.5:1 and 3:1 on the app's dark palette
• Nothing needs a drag: slides can be reordered from a menu or VoiceOver actions, and the pane divider and table picker have keyboard and VoiceOver equivalents
• Respects Reduce Motion and Smart Invert

Markdown Documents

MarpUI also edits Markdown that isn't a presentation. New Document in the + menu, beside New Presentation, creates a plain Markdown file with no front matter. Documents you create are kept in a documents folder next to your decks, and are listed in the sidebar under their own heading, where they can be renamed or deleted.

MarpUI can also open Markdown files from Finder on a Mac or the Files app on iPad, and treats them by what they are:

• A deck in your MarpUI folder opens as that deck
• A presentation from somewhere else (front matter with marp: true) is added to your decks as a copy, and MarpUI tells you so
• Any other Markdown opens as a plain document: the same editor beside a continuous preview, with none of the slide controls. It is edited where it lives and saved back to the original file

The preview follows the editor. Whatever the selected lines render to is highlighted in the preview, and when it is out of sight the preview scrolls to bring it level with the selection.

A document has the same Insert and Blocks menus as a deck, without the items that only a slide can use. The menu under its name saves it, renames it (for documents kept in your library) and exports it as a self-contained HTML page or a PDF. Exports are dark text on white, laid out on A4 or US Letter pages for PDF, rather than in the preview's dark colours.

Documents get the same Markdown extensions as slides, including tables, task lists, alerts, syntax highlighting and Mermaid diagrams, but not maths. A leading YAML front matter block is left out of the preview. Scripts inside a document are never run. Images referenced by a relative path next to the file are not shown, because the system only grants MarpUI access to the one file you opened.

AI Integration (MCP Server, Mac only)

On a Mac, MarpUI includes a built-in Model Context Protocol server that lets AI assistants such as Claude create, edit, and manage your decks and themes. It offers the same tools as the MarpUI web app, so an assistant can drive either one the same way.

Enabling. Open Settings and turn on Enable MCP Server. It starts straight away, with no restart, and Settings shows the endpoint, by default http://127.0.0.1:4747/mcp (Streamable HTTP). The port can be changed there. The server is off until you turn it on, runs only while MarpUI is open, and only accepts connections from the same Mac.

Connecting from Claude Code:

claude mcp add --transport http marpui http://127.0.0.1:4747/mcp

Connecting from Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "marpui": {
      "command": "npx",
      "args": ["mcp-remote", "http://127.0.0.1:4747/mcp"]
    }
  }
}

Available tools:

Tool	Description
list_decks	List all slide decks with metadata
get_deck	Read the full markdown of a deck
create_deck	Create a new slide deck
update_deck	Update deck markdown content
delete_deck	Delete a deck (moves to trash)
rename_deck	Rename a deck (updates title and filename)
list_themes	List available themes
get_theme	Read custom theme CSS
create_theme	Import a new custom theme
update_theme	Update custom theme CSS
delete_theme	Delete a custom theme
migrate_theme	Migrate a legacy flat theme into subdirectory layout
upload_image	Upload a base64-encoded image (optionally scoped to a deck)
list_images	List image files (optionally scoped to a deck)
list_fonts	List fonts available for a deck (deck-local + active theme) with parsed family/weight/style
upload_deck_font	Upload a base64-encoded font to a deck's fonts/ folder
upload_theme_font	Upload a base64-encoded font to a theme's fonts/ folder (auto-migrates flat themes)
list_theme_assets	List image assets bundled with a theme
upload_theme_asset	Upload a base64-encoded image to a theme's assets/ folder (auto-migrates flat themes)
delete_theme_asset	Delete a single theme asset by filename
render_markdown	Render Marp markdown to HTML/CSS

A deck that is open in the editor reloads when an assistant changes it. If you have unsaved edits of your own, MarpUI asks which version to keep.

Requirements

• iPadOS 26.0 or later, or macOS 26.0 or later
• On iPad: iPad only (optimised for iPad, not available on iPhone)
• On Mac: a Mac Catalyst build of the same app, for Apple silicon and Intel

Building from Source

Prerequisites

• Xcode 16+
• XcodeGen (brew install xcodegen)
• Node.js 20+ (for building the Marp rendering bundle)

Steps

1. Clone the repository:

   git clone https://code.squarecows.com/ric/marpUI-swift.git
   cd marpUI-swift
   

2. Build the Marp rendering bundle:

   cd Scripts/marp-bundler
   npm install
   node build.mjs
   cd ../..
   

3. Generate the Xcode project:

   xcodegen generate
   

4. Open in Xcode:

   open MarpUI.xcodeproj
   

5. Set your development team in Signing & Capabilities and build. Choose an iPad destination for the iPad app, or My Mac (Mac Catalyst) for the Mac app.

Architecture

MarpUI uses a hybrid approach:

• SwiftUI + UIKit for the native UI
• JavaScriptCore runs a bundled marp-bundle.js (marp-core + all markdown-it plugins + highlight.js) for Marp rendering
• WKWebView displays the rendered HTML/CSS slides with full theme and diagram support
• Mermaid.js bundled for diagram rendering inside the WebView
• Network.framework hosts the Mac-only MCP server: a small HTTP listener bound to the loopback interface, with the tools as thin wrappers over the same storage and renderer the UI uses

The rendering pipeline: Markdown → JavaScriptCore (marp-core) → HTML/CSS → WKWebView

Markdown files that aren't presentations take the same route through a plain markdown-it renderer in the same bundle, and are shown as one scrolling page.

Project Structure

MarpUI/
  App/                    — App entry point, external display manager
  MCP/                    — Mac-only MCP server: HTTP listener, JSON-RPC sessions, tools
  Models/                 — Deck, Slide, AppSettings, PresentationState, ThemeInfo
  Services/               — MarpRenderer, DeckStorage, ThemeStorage, ExportService, ImageManager, SlideThumbnailStore
  Views/
    Common/               — MarpWebView, HelpView, OnboardingView
    DeckList/             — Sidebar deck browser
    Document/             — Editor and preview for Markdown files that aren't presentations
    Editor/               — Split-pane editor, code editor, slide strip, table picker
    Presentation/         — SlideshowView, PresenterView
    Themes/               — Theme browser and editor
    Settings/             — App settings
  Utilities/              — Color theme, slug generator, platform check
  Resources/              — marp-bundle.js, mermaid.min.js
Scripts/
  marp-bundler/           — Node.js project that builds the JS rendering bundle

Related Projects

• MarpUI Web — The original web-based version (Node.js/React)
• Marp — The Marp ecosystem

License

MIT

Author

Built by Ric Harvey / squarecows