DocsForge Stress Test

Welcome to the DocsForge stress test! This site exercises every built-in feature.

Admonitions (All Types)

Collapsible Admonitions

Math Rendering (KaTeX)

Inline Math

Einstein's famous equation: \(E = mc^2\)

Schrödinger equation: \(i\hbar\frac{\partial}{\partial t}\Psi(r,t) = \hat{H}\Psi(r,t)\)

Fourier transform: \(\hat{f}(\xi) = \int_{-\infty}^{\infty} f(x)e^{-2\pi ix\xi}dx\)

Display Math

Quadratic formula:

Maxwell's equations:

Matrix operations:

Calculus:

Statistics:

Code Highlighting (Pygments)

Python

class DocsForge:
    """Self-contained documentation engine."""

    def __init__(self, config_path: str = "docsforge.yml"):
        self.config = self._load_config(config_path)
        self.plugins = self._load_plugins()

    def build(self, site_dir: str = "site") -> bool:
        """Build documentation to static HTML."""
        try:
            self._render_pages()
            self._copy_assets()
            self._run_post_hooks()
            return True
        except BuildError as e:
            log.error(f"Build failed: {e}")
            return False

    @property
    def version(self) -> str:
        return __version__

JavaScript/TypeScript

interface DocsForgeConfig {
    site_name: string;
    theme: ThemeConfig;
    plugins?: PluginConfig[];
}

class DocsForgeBuilder {
    private config: DocsForgeConfig;

    constructor(config: DocsForgeConfig) {
        this.config = config;
    }

    async build(): Promise<BuildResult> {
        const pages = await this.renderPages();
        const assets = await this.copyAssets();
        return { pages, assets, success: true };
    }
}

Rust

use std::path::PathBuf;

pub struct DocsForge {
    config: Config,
    plugins: Vec<Box<dyn Plugin>>,
}

impl DocsForge {
    pub fn new(config_path: &str) -> Result<Self, ConfigError> {
        let config = Config::load(config_path)?;
        let plugins = PluginManager::load_all(&config)?;
        Ok(Self { config, plugins })
    }

    pub fn build(&self, output_dir: PathBuf) -> Result<(), BuildError> {
        self.render_pages(&output_dir)?;
        self.copy_assets(&output_dir)?;
        Ok(())
    }
}

Go

package main

import (
    "fmt"
    "os"
)

type Config struct {
    SiteName string `yaml:"site_name"`
    Theme    string `yaml:"theme"`
}

func Build(configPath, outputDir string) error {
    cfg, err := LoadConfig(configPath)
    if err != nil {
        return fmt.Errorf("load config: %w", err)
    }

    if err := RenderPages(cfg, outputDir); err != nil {
        return fmt.Errorf("render: %w", err)
    }

    return CopyAssets(outputDir)
}

Bash

#!/bin/bash
set -euo pipefail

DOCSFORGE_VERSION="10.1.0"
SITE_DIR="site"

echo "Building DocsForge v${DOCSFORGE_VERSION}..."

# Clean previous build
rm -rf "${SITE_DIR}"

# Build documentation
docsforge build --site-dir "${SITE_DIR}"

# Verify output
if [[ -f "${SITE_DIR}/index.html" ]]; then
    echo "Build successful!"
    exit 0
else
    echo "Build failed!"
    exit 1
fi

SQL

-- Create documentation pages table
CREATE TABLE pages (
    id SERIAL PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    slug VARCHAR(255) UNIQUE NOT NULL,
    content TEXT,
    tags TEXT[],
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW()
);

-- Index for tag search
CREATE INDEX idx_pages_tags ON pages USING GIN (tags);

-- Get all pages with specific tag
SELECT title, slug, updated_at 
FROM pages 
WHERE 'docsforge' = ANY(tags)
ORDER BY updated_at DESC;

YAML

site_name: DocsForge Demo
theme:
  name: material
  palette:
    - scheme: default
      primary: teal
      accent: teal
plugins:
  - search
  - tags
  - blog
markdown_extensions:
  - admonition
  - pymdownx.highlight
  - pymdownx.superfences

Content Tabs

print("Hello from Python!")

console.log("Hello from JS!");

println!("Hello from Rust!");

Tables

Simple Table

Complex Table

Wide Table

Task Lists

Setup Checklist

• Install DocsForge (pip install docsforge)
• Create new project (docsforge new my-docs)
• Write first page (docs/index.md)
• Start dev server (docsforge serve)
• Verify all features work
• Build for production (docsforge build)
• Deploy to GitHub Pages
• Share with team
• Write blog post about it

Feature Checklist

• Admonitions (all 12 types)
• Math (inline + display)
• Code highlighting (8+ languages)
• Tables (simple + complex)
• Content tabs
• Task lists
• Footnotes
• Definition lists
• Abbreviations
• Emojis
• Blog posts
• Tags
• Search
• Dark mode toggle
• Privacy (self-hosted fonts)
• Minification

Footnotes

DocsForge includes powerful features by default¹. The privacy plugin downloads external assets², while minify compresses output³.

Definition Lists

DocsForge

A self-contained documentation engine that bundles Material theme, all plugins, and all extensions into a single installable package.

Material for MkDocs

The world's most popular documentation theme, created by Martin Donath. DocsForge vendors it for zero-config usage.

PyMdownX

A collection of Markdown extensions that add advanced syntax like admonitions, superfences, and task lists.

Pygments

A syntax highlighting library written in Python. DocsForge uses it for build-time code highlighting.

KaTeX

A fast math typesetting library. DocsForge vendors it for zero-config math rendering.

Abbreviations

DocsForge uses the HTML spec maintained by the W3C. Styling is done via CSS, and interactivity with JS.

Emojis

DocsForge is built with love.

Zero to docs in seconds.

Everything is bundled.

Search works out of the box.

Dark mode included.

Syntax highlighting for all languages.

Math rendering with KaTeX.

All features work without configuration.

Blockquotes

"Documentation is a love letter that you write to your future self."
— Damian Conway

"The best documentation is the documentation that gets written."
— DocsForge Philosophy

The privacy plugin ensures your documentation works offline by downloading and caching external assets during the build process. This includes Google Fonts, CDN scripts, and other external resources.

Horizontal Rules

Above the first rule.

Between two rules.

Below the second rule.

HTML in Markdown

Nested Structures

Lists within Admonitions

print("Hello from inside a tip!")

Admonitions within Lists

1. First item

   Note in list

   This admonition is inside a list item.

2. Second item

   # Code in list
   x = 42
   

3. Third item with table

   Col 1	Col 2
   A	B
   C	D

Critic Markup

This is added text and this is removed text.

Here is a substitutionreplacement.

And a highlightwith a comment.

Keys

Press Ctrl+C to copy.

Press Ctrl+V to paste.

Press Ctrl+Alt+Del to open Task Manager.

Use Up and Down to navigate.

Mark and Tilde

This is marked text for highlighting.

This is deleted text for strikethrough.

This is ^superscript and _subscript.

Snippets