Pandoc is a universal document converter written in Haskell. It reads input in dozens of formats (Markdown, LaTeX, HTML, docx, EPUB, Org, RST, MediaWiki, etc.) into a common abstract syntax tree (AST), then writes to a wide range of output formats. The system is modular: readers parse source formats, writers produce target formats, and a template system controls output structure. It includes an integrated citation processor (citeproc), a Lua scripting engine for custom readers/writers/filters, and a server mode (HTTP API). The codebase is a monolith library with separate CLI, server, and Lua engine packages, plus a WebAssembly build for browser use. It is heavily tested with golden tests and property tests. The architecture demonstrates strong separation of concerns, with reusable parsing utilities, a well-defined AST, and a flexible extension mechanism via Lua. While the codebase is large and complex, it is actively maintained and exhibits high craftsmanship in its modular design and handling of diverse formats.
OfficeCLI is a cross-platform CLI application written in C#/.NET that creates, reads, and mutates OOXML Office documents (Word .docx, Excel .xlsx, PowerPoint .pptx) without requiring Microsoft Office. It is explicitly engineered as an agent-facing tool: every document element is addressable through a uniform path syntax (e.g. /slide[1]/shape[2]), all commands emit structured JSON with error codes and suggestions, and it ships AI-skill files for Claude/Copilot/Cursor/Codex, an MCP server, plus Python and Node SDKs. The core operation model is a batch command language: documents are mutated by replayable JSON items (add/set/remove/get) executed atomically through the CLI or over a named pipe to a resident process. Architecturally the repo is a single .NET binary (embedded runtime) with a CommandBuilder layer, a DocumentHandlerFactory dispatching to three large partial-class handlers (WordHandler, ExcelHandler, PowerPointHandler), and a shared Core layer containing chart-to-SVG rendering, a formula evaluator implementing 350+ Excel functions with statistical distributions, pivot table construction, Mermaid diagram parsing, OOXML theme/table-style resolution, HTML/PNG/SVG preview rendering, and a plugin protocol for foreign-format dump-readers and exporters. Security is taken seriously: SsrfGuard validates remote fetch targets, HyperlinkUriValidator allowlists URI schemes, XmlTextValidator and DocumentLimits guard against decompression bombs and DOM sprawl, and AtomicPackageWriter prevents torn file writes. Quality is strong but carries real maintenance debt. The code demonstrates deep OOXML craftsmanship - schema-order-correct XML insertion, exact EMU unit round-trips, Lanczos-based gamma functions, and curated chart-style galleries. However, handlers are split across dozens of partial-class files that evolved from former god methods, the property API is stringly-typed (props dictionaries parsed per key), examples must be maintained in parallel shell and Python twins, and the tool deliberately tolerates 'UNSUPPORTED props' warnings (exit code 2), which can mask incomplete feature coverage. The best reuse targets are the self-contained Core utilities rather than the format handlers. The project is actively maintained with multi-platform CI publishing to npm and PyPI.
Presenton is an AI-powered presentation generation platform that allows users to create presentations from text prompts, document uploads, or template selections using multiple LLM and image providers. The application features a monorepo architecture with a FastAPI backend, Next.js frontend, and Electron desktop client. Key capabilities include AI-driven outline and slide generation, visual slide editing, document processing via LiteParse, export to PPTX/PDF formats, chat-based presentation refinement, and community template sharing. The system demonstrates strong engineering practices with modular service architecture, secure handling of sensitive data, and reusable components for configuration management, document conversion, and provider abstraction.
presenterm is a Rust-based CLI application that renders Markdown presentations directly in the terminal. It parses Markdown into a structured intermediate representation via comrak, then builds slides as sequences of render operations. The rendering engine supports rich text, images, code highlighting through bat/syntect, column layouts, themes, slide transitions, footers, speaker notes, and interactive keyboard-driven navigation. It also includes PDF/HTML export backends and hot-reload for live presentation development.
Slidev is a developer-oriented slide presentation tool that turns Markdown files into interactive, web-based slide decks. The system is built as a monorepo with several packages: a Node.js CLI and Vite-based dev server (`packages/slidev`), a Vue 3 client application (`packages/client`), a markdown parser (`packages/parser`), shared type definitions (`packages/types`), a VS Code extension (`packages/vscode`), and scaffolding tools (`create-app`, `create-theme`). The core workflow involves parsing Markdown slides with frontmatter, rendering them as Vue components with support for code highlighting (Shiki), diagrams (Mermaid, PlantUML, KaTeX), interactive editors (Monaco), animations (v-click, v-mark), and drawing tools. Export capabilities include PDF, PPTX (both raster and editable), PNG, and Markdown via Playwright. The system also includes a Model Context Protocol (MCP) server for AI agent integration, enabling programmatic slide editing. The architecture is modular: the parser handles slide splitting and feature detection, the client provides a rich presentation UI with presenter mode, and the CLI orchestrates build, serve, and export commands. The VS Code extension adds language support, a preview panel, and AI tools. Overall, Slidev is a mature, feature-rich application for creating technical presentations with minimal friction.
PPT Master is a Python-based application designed to generate natively editable PowerPoint (PPTX) presentations from diverse source formats including PDF, DOCX, Markdown, and URLs. The system operates as a CLI tool and AI agent skill, orchestrating a workflow that converts source content into SVG intermediates before rendering them into native DrawingML shapes within the PPTX file. This approach prioritizes editability over flattened image exports, allowing users to modify text and shapes directly in PowerPoint. The architecture relies heavily on external AI APIs for content generation and image creation, with a local Flask server providing live preview and confirmation capabilities. The codebase functions as a presentation engineering toolkit, featuring bidirectional conversion between PPTX and SVG, template management, and asset handling. It enforces strict design constraints via machine-readable 'spec_lock' files to maintain visual consistency across generated decks. The application is structured as a modular skill within AI IDEs (Claude Code, Cursor), allowing developers to invoke presentation generation via chat commands. While the core conversion logic is robust, the system's stability is intrinsically linked to the availability and schema of external AI providers and the specific behavior of the python-pptx library. This repository represents a hybrid of application engineering and data pipeline logic. While the primary output is a software artifact (the PPTX file), the internal processing involves significant data transformation (document parsing, image generation, XML manipulation). The extensive example suite serves as both documentation and regression testing for the conversion engine, demonstrating the tool's capability across technical, business, and artistic domains.
PPTAgent is an agentic framework for automatic PowerPoint presentation generation from documents. It operates as a production-grade application with CLI, web UI, Docker deployment, and an MCP server for integration with external tools like Claude and Cursor. The system uses a two-stage pipeline: analysis (induction of slide layouts and content schemas from reference presentations) and generation (editing actions via a structured API). It supports multiple generation modes—freeform (DeepPresenter) and template-based (PPTAgent)—and includes a multi-agent orchestration loop with planner, research, and design agents. The codebase is split into two packages: `pptagent` (core generation library and evaluation framework) and `deeppresenter` (production runtime with CLI, Docker, and HTML-to-PPTX conversion). While primarily an application, it has strong research roots, including academic papers at EMNLP 2025 and ACL 2026, an evaluation framework (PPTEval) for content, style, and coherence scoring, and a set of induced slide templates. The architecture is modular, with role-based agents defined in YAML, MCP-based tool servers, and a presentation data model with closure-based editing. External dependencies include OpenAI, Tavily, SerpAPI, MinerU, and Docker, making it a complex but well-structured system for automated presentation creation.
Carbon is a Next.js web application for creating and sharing beautiful images of source code. It provides a CodeMirror-based editor with extensive customization: syntax themes (30+ built-in), fonts (13 options), background colors/images (including Unsplash integration), window themes, padding, shadows, and line numbers. Users can import code via paste, file drop, or GitHub Gist URLs. Export options include PNG/SVG at multiple resolutions, clipboard copy, Twitter sharing, Imgur upload, and embed codes. Saved snippets persist via Firebase authentication with automatic Twitter/Slack unfurling. The app runs as a PWA for offline use. Architecture is a Next.js 12 monolith with API routes for oEmbed and server-side image generation (Puppeteer/Chrome AWS Lambda). State is managed through URL parameters (with base64-encoded complex state), localStorage, and React state. The codebase demonstrates solid engineering with custom CodeMirror modes for 6 languages, a sophisticated theme builder, and well-encapsulated UI components.
PPTist is a full-featured web-based slide editor and presentation application, built with Vue 3, TypeScript, and Pinia. It replicates core PowerPoint functionality entirely in the browser, supporting text, image, shape, line, chart, table, video, audio, and LaTeX elements. Users can create, edit, animate, and present slides, with import/export support for PPTX, PDF, images, and a custom .pptist format. An AI-assisted slide generation feature allows users to input a topic and receive a complete slide deck via an external API, with template-based layout and image selection. The architecture is a single-page application with a custom canvas rendering system, rich text editing via ProseMirror, and state management through Pinia stores. The editor is divided into three main modes: Editor (full editing with thumbnails, toolbar, and canvas), Screen (presentation with speaker notes, audience view, writing board, and laser pointer), and Mobile (basic editing and preview for touch devices). Data persistence uses IndexedDB via Dexie for undo/redo snapshots, and slide data is stored as JSON in Pinia stores. External dependencies include ECharts for charts, pptxgenjs for PPTX export, and a backend server for AI generation and image search. Key entry points include src/App.vue (top-level routing), src/views/Editor/index.vue (main editor), src/views/Screen/index.vue (presentation mode), and src/views/Mobile/index.vue (mobile mode). Data flows center on the slide store: user actions trigger mutations captured as snapshots for undo/redo, export processes convert internal JSON to target formats, and import parses external files into the internal schema. The AI PPT flow sends a user prompt to the backend, receives an outline and slide data, then fills template slides with content and images. The application is actively maintained with a large community (9386 stars, 1770 forks) and is licensed under AGPL-3.0. It relies on an external backend for AI features and image search, meaning those features are not self-contained. The codebase is well-structured but lacks automated tests, and some components (e.g., HTML parser, shape library) are self-contained and potentially reusable in other projects.
This repository implements an AI-agent skill that converts images, PDFs, and image-based PPT/PPTX files into fully editable PowerPoint (.pptx) documents. The system uses a deterministic CLI state machine (`editppt`) with a four-phase workflow: normalize input into per-page jobs, dispatch to subagents for page reconstruction, record page manifests, and finalize by rebuilding the PPTX from manifests. It integrates OCR (PaddleOCR or offline detector) for text bounding boxes, image generation/editing backends (built-in, OpenAI-compatible, or Codex OAuth), and LaTeX rendering for formulas. The output preserves native text boxes, shapes (including custom paths and polygons), tables, images, and speaker notes, with strict provenance tracking for all assets. The codebase is well-structured with clear separation of concerns, a manifest-driven assembly pattern, and comprehensive tests. However, the last commit date is anomalously in the future (2026-09-16), suggesting the repository may be abandoned or the timestamp is erroneous; combined with only 1 open issue and no recent activity, it is classified as stale. The technical drift is low as the code uses modern Python and standard libraries, but external dependencies (OCR, image APIs, LaTeX) may become incompatible over time.
This repository is a Claude Code plugin and design system library for generating zero-dependency HTML presentations. It provides a structured workflow (SKILL.md) for an AI agent to create single-file slide decks with inline CSS/JS, featuring 34+ curated design templates (bold-template-pack) with detailed color palettes, typography scales, component definitions, and CJK internationalization guidance. The core runtime component is a reusable `<deck-stage>` web component that handles slide navigation, keyboard controls, auto-scaling, print support, and speaker notes. Supporting scripts enable Vercel deployment, PDF export via Playwright, and PowerPoint-to-JSON extraction. The repository is primarily a design specification library consumed by an AI coding agent, not a standalone application. It exhibits a hybrid nature: the templates are extensive design documentation (not executable code), while the plugin infrastructure and web component are functional code. The design philosophy emphasizes anti-generic aesthetics, fixed 16:9 stage scaling, and progressive disclosure of supporting files. Notable duplication exists between root and plugin paths, and all templates are marked alpha.
This repository is an awesome list (curated resource collection) for the Marp Markdown Presentation Ecosystem. It categorizes and links to official Marp projects, community tools, themes, plugins, and example deployments. There is no executable application code, data pipeline, or library; the entire content is a single README.md file with markdown formatting and a CI workflow (awesome-lint + Prettier) to enforce quality. The repo is actively maintained with recent commits and clean CI. It serves as a central discovery hub for the Marp community, but offers no reusable software components or data assets.