Documentation Viewer

Documentation Viewer

"Documentation that requires leaving the editor is documentation that won't be read."

---

The Problem

UE5 plugin documentation typically lives in one of three places: a website you have to open in a browser, a PDF you have to find on disk, or comments in the source code you have to navigate to in your IDE. All three require a context switch — you leave the editor, find the information, then try to remember it while switching back.

The friction is small but cumulative. Over the course of a day, a developer might check documentation dozens of times. Each switch costs 10-30 seconds of navigation and a cognitive reset. Multiply by a team, multiply by weeks, and the cost becomes real.

Some UE5 plugins solve this by embedding a web browser (CEF/Chromium) inside the editor. This works, but at a cost: CEF brings its own process, its own memory footprint, and its own startup time. For a documentation viewer, this is overkill — you are rendering Markdown text, not running a web application.

---

The Solution

The PGX Documentation Viewer renders Markdown directly in Slate — Unreal's native UI framework. No web browser. No CEF. No Chromium. No external process.

Native Rendering

Markdown is parsed into a tree structure, then rendered as native Slate widgets:

• Headings become styled text blocks with appropriate font tokens
• Code blocks render with monospace fonts and background tinting
• Lists render with proper indentation and bullet/number markers
• Links become clickable hyperlinks that navigate within the documentation set
• Tables render as structured Slate layouts
• Inline formatting (bold, italic, code) applies directly to rich text

The result looks like documentation, not like a web page crammed into an engine panel. It respects the editor's visual language and responds to the same density and theme settings as other PGX panels.

Full-Text Search

Type a query, get results across all 90+ documentation files. Search indexes are built on startup and updated when files change. Results show the file name, matching line, and surrounding context. Click a result to navigate directly to the match.

Bookmarks

Mark frequently referenced pages for quick access. Bookmarks persist between editor sessions. Useful for pinning API reference pages, architecture overviews, or setup guides that you reference repeatedly during development.

Live Reload

A file watcher monitors the documentation directory. When you edit a Markdown file in your text editor, the Documentation Viewer updates automatically — no manual refresh, no panel restart. This makes documentation authoring a live-feedback loop: write in your editor, see the result in the panel.

Cross-Reference Navigation

Documentation files can link to each other using standard Markdown link syntax. Clicking a cross-reference navigates to the target document within the same panel. The navigation history supports back/forward traversal.

---

Content

The documentation set covers:

• Architecture documents (one per system, ~20 files): Deep technical documentation of each system's design, state machines, data flow, and integration points
• Usage guides (~20 files): How to configure and use each system from both Blueprint and C++
• Testing guides (~10 files): How to test each system, including the standardized test utility functions
• Extension guides (~13 files): How to customize and extend each system — overriding defaults, subclassing, hooking delegates
• Inspector guides (~13 files): How to read and use each system's editor inspector panel
• Development references: Coding conventions, tag architecture, editor wiring checklists

All documentation is bilingual (English/Spanish) at the section level.

---

Why Native Slate

The decision to use native rendering instead of an embedded browser was deliberate:

• No CEF dependency: The editor does not spawn a Chromium process for documentation. Memory footprint stays minimal.
• Consistent styling: Documentation respects the same design tokens as other PGX panels. It looks like part of the editor, not like a web page.
• Fast startup: No browser initialization delay. The panel is ready the moment you open it.
• No security surface: CEF brings a full browser engine with all its potential vulnerabilities. Native Slate rendering has none of those concerns.
• Lighter builds: Projects using PGX do not need to ship the WebBrowser module dependency.

The tradeoff is that native rendering does not support every Markdown extension or embedded media format. For PGX's documentation needs — text, code, tables, links, lists — native rendering covers the full surface.

---

Architecture

The rendering pipeline:

1. Parse: Markdown source is parsed into a tree of typed elements (heading, paragraph, code block, list, table, link, inline format)
2. Layout: The element tree is walked to produce a Slate widget hierarchy
3. Render: Slate handles layout, scrolling, and interaction
4. Update: File watcher detects changes and triggers re-parse/re-render

The parser uses a proven C library for Markdown parsing, ensuring correct handling of edge cases in Markdown syntax. The Slate rendering layer is PGX-specific — it maps Markdown elements to the framework's visual token system.