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.
nb is a command-line note-taking, bookmarking, and archiving tool with Git-backed versioning, encryption, full-text search, tagging, pinning, and a built-in web server for browsing. It is implemented primarily as a single portable Bash script, with optional Go, Ksh, and Zsh wrappers. The architecture is a monolith CLI with a plugin system for extending subcommands and themes. Key entry points are the `nb` script and its aliases `bin/notes` and `bin/bookmark`. Data flows involve creating/editing notes in `NB_DIR`, where each notebook is a Git repository; operations create automatic commits, and an `.index` file per folder maintains ordering. The tool supports multiple notebooks, nested folders, encryption (OpenSSL/GPG), bookmark import from browsers, and remote sync via Git. The extensive test suite (2200+ BATS tests) covers all major features and edge cases.
The OWASP Web Security Testing Guide (WSTG) is a comprehensive, community-maintained documentation project defining standard test cases for web application security assessments. It is primarily a structured knowledge base written in Markdown, organized by testing categories including Information Gathering, Authentication, Injection, and API Testing. The repository also serves as the source for multiple derived artifacts: a Jekyll static website (wstg.owasp.org), downloadable PDF/EPUB ebooks via a Pandoc+Typst pipeline, and machine-readable test checklists in JSON, XLSX, and Markdown formats. The build infrastructure includes Python scripts for site generation and navigation, GitHub Actions for CI/CD (linting, link checking, deployment), and a versioned release process that supports multiple channels (latest, stable, past versions). Although the primary content is documentation, the repository functions as a publication platform with significant automation and is actively maintained by a community of contributors. It is not a software application in the traditional sense, but the build tooling and CI/CD pipelines qualify it as an application-focused project with strong data engineering characteristics in its checklist generation and structured content management.
ZotLit is a dual-plugin system (Obsidian plugin + Zotero addon) that bridges Zotero's reference management with Obsidian's note-taking environment. It enables users to create literature notes from Zotero items, insert formatted citations, import annotations, and export documents via Pandoc — all within Obsidian. The system is a monorepo with three main applications: an Obsidian plugin (apps/obsidian) that provides views (annotation sidebar, references panel, citation popover, template data explorer), services (citation indexing, live updates from Zotero, Pandoc integration, note creation/update), and a settings tab; a Zotero addon (apps/zotero) that extends Zotero's menus, database status, and freshness signaling; and a documentation site (apps/docs) built with TanStack Router and Fumadocs on Cloudflare Workers. The architecture is service-oriented on the Obsidian side, with approximately 20 services wired in a service container (build.ts) using AsyncDisposableStack for lifecycle management. Shared packages (@zotlit/db, @zotlit/templates, @zotlit/protocol, @zotlit/obsidian-i18n, @zotlit/item-lookup) provide database queries over Zotero's SQLite via Drizzle ORM, template rendering with Eta/Liquid engines, a versioned HTTP wire protocol between Zotero and Obsidian, i18n Language Pack compilation, and a search index for item lookup. The codebase is well-tested with Vitest, employs modern TypeScript patterns, and maintains a comprehensive typed contract system for template data. Key workflows include: bidirectional citation linking (pandoc-style and wikilink), live preview of citations in reading view, annotation import from PDF/EPUB/snapshots with turndown HTML-to-Markdown conversion, Pandoc export with a bundled Lua filter and pinned WASM engine, batch note creation from collection selections, and a template workbench CLI for debugging and authoring templates. The system relies on Zotero's local SQLite database as the authoritative source, with a freshness detection mechanism (WAL checkpoint polling) to trigger updates in Obsidian.
Jimmy is a command-line and terminal UI tool for converting notes from 50+ note-taking applications (Evernote, Obsidian, Joplin, Notion, Bear, etc.) into a unified Markdown format. It uses an intermediate representation (Notebook/Note/Resource/Tag objects) decoupled from input parsing and output writing, allowing clean extensibility. The architecture is a plugin-style converter framework with a rich set of format-specific parsers, markdown preprocessing libraries, and a resource deduplication system. The tool is distributed as standalone binaries bundling Pandoc and other dependencies. While the core abstractions are well-crafted, the vast majority of the codebase consists of tightly coupled format converters that are specific to each app's export schema, limiting general reuse. The project has extensive integration tests via a test data submodule, but many converters lack unit tests. Its requirement for Python 3.14 (a very recent version) and reliance on external binaries (Pandoc, one2html) introduce drift risks.
This repository provides a Python CLI tool and Makefile pipeline to scrape all essays from Paul Graham's website (paulgraham.com), convert them to Markdown, and produce an EPUB ebook. The core logic resides in a single script (`graham.py`) that uses `requests`, `BeautifulSoup`, `html2text`, and `htmldate` to download, parse, and date-stamp each essay. A `Makefile` orchestrates the full build: creating a virtual environment, fetching essays, merging them with `pandoc`, and generating the final EPUB with a custom CSS and an iBooks dark-mode patch. The CI workflow (GitHub Actions) runs daily, detects new essays by comparing article counts, and automatically creates a release with the updated EPUB and metadata CSV. The architecture is straightforward—no web server, database, or tests—but the pipeline is robust and well-documented for its single purpose. While the scraper is tightly coupled to Paul Graham's site structure, several components (the iBooks patcher, the footnote conversion function, and the EPUB stylesheet) are cleanly isolated and reusable in other EPUB generation projects.
This repository is a documentation build system for producing a study guide for the Claude Certified Architect - Foundations exam. The core functionality resides in the `exam-preparation-guide.md` source file, which is transformed into PDF and EPUB formats via a Pandoc-based build script. The architecture is straightforward: a shell script (`scripts/build-release-assets.sh`) processes the Markdown with Pandoc, applying styling and metadata from the `publishing/` directory, and outputs artifacts to `dist/`. A GitHub Actions workflow (`.github/workflows/release.yml`) automates the build and release process when version tags are pushed. The system relies on external dependencies like Pandoc, XeLaTeX, and standard TeX Live packages for PDF generation. While not a complex software application, it demonstrates solid documentation engineering practices with a reusable build pipeline and clear separation of concerns between content, styling, and build automation.