Litho (deepwiki-rs)

Litho (deepwiki-rs): AI-Driven Architecture Documentation in Rust

Litho is a high-performance, AI-powered documentation generation engine designed to automatically analyze your codebase and produce professional, up-to-date architecture documentation in the C4 model format. Built with Rust, Litho aims to eliminate the drudgery of manual documentation, ensuring your repository always ships with accurate, navigable diagrams and context-rich explanations.

What Litho Does

Litho transforms raw code into a polished, coherent repository-wide document set. It analyzes source files across multiple languages, infers architectural roles and data flows, and produces:

• Context diagrams (system context)
• Container diagrams (system containers)
• Component diagrams (container components)
• Code-level documentation and examples

The result is a complete, navigable, and visually consistent documentation package that stays in sync with your code. No more stale markdown files that lag behind the code changes; Litho keeps documentation aligned with the evolving software.

From Messy Code to Beautiful Documentation

Traditionally, documentation lags behind development. Teams wrestle with outdated READMEs, scattered markdown files, and inconsistent diagrams. Litho changes this paradigm by automatically generating documentation from the codebase with a consistent structure and professional C4 model diagrams. The difference is stark:

• Before Litho:

• Manual documentation that often becomes outdated, incomplete, or missing

• Updates lagging behind code changes

• Inconsistent formatting and structure

• Time-consuming maintenance

• Difficult navigation and comprehension

• After Litho:

• AI-generated documentation directly from the codebase

• Always up-to-date with the latest code

• Professional C4 model structure with consistent formatting

• Easy navigation and clear relationships between components

• Comprehensive coverage, including context, containers, components, and code excerpts

Litho in a Nutshell

Litho is an AI-powered documentation engine that automatically analyzes codebases and renders architecture documentation in the C4 hierarchy. It focuses on keeping your documentation in sync with your code and delivering diagrams and textual explanations that reveal system boundaries, responsibilities, and data flows. It is designed to support teams that demand high-quality, auditable documentation as part of their development pipeline.

Why Use Litho

Litho isn’t just a one-off documentation tool. It’s a relentless keeper of your architectural truth. Here are the core benefits:

• Automatic synchronization: Documentation is updated as code changes, reducing manual rewrite effort.
• Time savings: Save hundreds of hours previously spent drafting and updating docs.
• Improved onboarding: New team members get a complete, up-to-date picture of the architecture.
• Better code reviews: Clear architectural context accelerates review cycles.
• Compliance and auditable docs: Automated generation supports governance needs.
• Multi-language support: Works with Rust, Python, Java, Go, C#, JavaScript, and more.
• Professional diagrams: Generate context, container, component, and code diagrams that communicate the architecture clearly.
• CI/CD integration: Generate documentation on every commit, ensuring continuous alignment with the pipeline.

Litho is suitable for: development teams of all sizes, open source projects, enterprise software developers, and anyone who wants to avoid the pain of outdated documentation.

Key Features & Capabilities

Core Capabilities

• AI-driven architecture documentation generation from codebase analysis
• Automatic generation of C4 model diagrams (Context, Container, Component, Code)
• Intelligent extraction of code comments, structures, and relationships
• Multi-language support across common programming languages
• Customizable templates for documentation output

Advanced Features

• External Knowledge Integration: Mount external documents (PDF, Markdown, SQL, and more) as knowledge sources to enrich analysis
• Database Documentation: Auto-generate database schema docs with ERD diagrams for SQL projects
• Git history analysis to track architectural evolution
• Cross-referencing between code elements and documentation
• Interactive documentation with embedded diagrams and examples
• Integration with CI/CD pipelines for automated documentation generation

Litho solves a common problem: outdated and incomplete technical documentation. It continuously analyzes the source to produce accurate, context-rich architectural documentation aligned with the live code.

Litho Eco: The Broader Ecosystem

Litho is part of a broader ecosystem designed to improve developer productivity and documentation quality. Two notable companion tools are:

Litho Book: A high-performance Markdown reader built with Rust and Axum, designed to browse documentation generated by Litho. Its features include real-time markdown rendering, full Mermaid chart support for architectural diagrams, intelligent search, high performance, and AI-driven document interpretation. See snapshots to get a feel for the interface:

• Snapshot view 1:
• Snapshot view 2:

Mermaid Fixer: A high-performance AI-driven tool that detects and fixes Mermaid diagram syntax errors in Markdown files. It scans directories, validates Mermaid syntax, and uses AI to correct issues, providing before/after reports. Integration with Litho ensures diagrams render correctly across the documentation.

• Mermaid Fixer snapshot 1:
• Mermaid Fixer snapshot 2:

How Litho Works: The Four-Stage Processing Pipeline

Litho’s architecture follows a four-stage processing pipeline that transforms raw code into comprehensive documentation:

• Phase 1: Preprocessing

• Code scanning and discovery across languages

• Structure and dependency extraction

• Original document extraction and core code insights

• Agent memory chunk initialization to enable incremental processing

• Phase 2: Intelligent Research & Analysis

• System context and domain module detection

• Workflow and boundary analysis

• Key module insights with memory-backed reasoning

• ReAct-style reasoning loops to refine interpretations

• Phase 3: Documentation Generation

• Overview, architecture, workflow, boundary, and key module editors

• Assembly of the final documentation with consistent formatting

• Creation of a document tree that maps to an output structure

• Phase 4: Verification & Enhancement

• Mermaid syntax verification and diagram repair

• Documentation integrity checks and coverage analysis

• Quality reporting and final documentation output

Four-Stage Visual Overview

• Input Phase: CLI startup collects configuration, scans structure, and extracts READMEs
• Analysis Phase: Language parsing and AI-enhanced analysis store results in memory
• Reasoning Phase: Orchestrates system-context, domain modules, workflows, and key insights
• Orchestration Phase: Generates the project overview, architecture diagrams, workflow docs, and module insights
• Output Phase: Persists documents, creates summary reports, and stores the final documentation

Core Modules You’ll Work With

• Code Scanner: Discovers and analyzes multi-language source code
• Language Parser: Extracts structural information using language-specific parsers
• Architecture Analyzer: AI-powered inference of patterns and relationships
• Diagram Generator: Creates Mermaid-based C4 diagrams
• Documentation Formatter: Produces clean, navigable documentation output

Core Process: The End-to-End Flow

• Scan: Find and analyze all source files
• Parse: Extract structural and semantic data
• Analyze: Apply AI models to infer architecture and relationships
• Generate: Create diagrams and documentation content
• Format: Structure content into a coherent, navigable format
• Export: Output to your preferred location and format

Getting Started: Prerequisites and Installation

Prerequisites

• Rust: Version 1.70 or later
• Cargo: Rust’s package manager

Installation Options

Option 1: Install from crates.io (Recommended)

• Command:
• cargo install deepwiki-rs

Option 2: Build from Source

• Steps:
• git clone https://github.com/sopaco/deepwiki-rs.git
• cd deepwiki-rs
• cargo build --release
• The compiled binary will be in target/release

Usage Guide: Quick Start

Litho provides a simple CLI to generate documentation from a codebase. For more configuration details, consult the CLI options documentation.

Basic commands

• Generate documentation in a target directory:
• deepwiki-rs -p ./my-project -o ./docs
• Generate in a specific language:
• deepwiki-rs --target-language en -p ./my-project
• deepwiki-rs --target-language ja -p ./my-project

Documentation Generation: Options and Examples

• Default run with all processing stages:
• deepwiki-rs
• Skip certain stages to experiment:
• deepwiki-rs --skip-preprocessing --skip-research

Advanced Options: Tailoring Litho to Your Needs

• Disable ReAct Mode to avoid auto-scanning project files:
• deepwiki-rs -p ./src --disable-preset-tools --llm-api-base-url --llm-api-key --model-efficient GPT-5-mini
• Run multiple models in parallel:
• deepwiki-rs -p ./src --model-efficient GPT-5-mini --model-powerful GPT-5-Pro --llm-api-base-url --llmapikey --model-efficient GPT-5-mini

External Knowledge Integration

Litho can mount external knowledge sources to augment analysis. Supported document types include:

• PDF
• Markdown
• SQL
• YAML/JSON
• Text

Knowledge categories help route content to the right agents:

• architecture
• database
• api
• deployment
• adr
• workflow
• general

Knowledge synchronization commands

• Sync external knowledge sources:
• deepwiki-rs sync-knowledge
• Force sync even if the cache is fresh:
• deepwiki-rs sync-knowledge --force

Knowledge configuration example (litho.toml)

• Example categories and paths include:
• architecture: docs/architecture/.md, docs/design/.pdf
• database: docs/database/.md, docs/schema/.sql
• Target agents:
• architecture category targets: SystemContextResearcher, ArchitectureResearcher, ArchitectureEditor
• database category targets: ArchitectureResearcher, DomainModulesDetector, KeyModulesInsight

Database Documentation

Litho automatically analyzes SQL database projects and SQL files to generate detailed documentation, including:

• Database projects and hierarchy
• Tables: schema, columns, data types, constraints, keys
• Views: definitions and references
• Stored procedures: parameters and tables accessed
• Functions: scalar and table-valued
• Relationships: foreign keys and ERD diagrams
• Data flows: ETL and data movement patterns

A generated database overview includes summary statistics, detailed schemas, and Mermaid ER diagrams.

Output Structure: How Litho Organizes Documentation

Litho produces a well-structured documentation tree that makes navigation intuitive:

• project-docs/
• 1. Project Overview
• 2. Architecture Overview
• 3. Workflow Overview
• 4. Deep Dive/Topic1.md, Topic2.md (nested topics)
• 5. Boundary-Interfaces
• 6. Database-Overview (SQL projects only)

Contributing to Litho

Litho welcomes contributions of all kinds. You can help by:

• Expanding language support
• Designing new templates and styles
• Improving Mermaid diagram generation
• Optimizing performance and memory usage
• Broadening test coverage
• Enhancing documentation and usage guides
• Fixing bugs and refining features

Development workflow (high level)

• Fork the repository and create a feature branch
• Implement feature, write tests, and document changes
• Open a pull request with a descriptive summary

License

Litho is MIT-licensed. A copy of the license is provided in the LICENSE file.

About the Author

Litho’s author invites you to sponsor the project and contribute to its growth. The maintainer has experience across PC and mobile internet, AI applications, and front-end systems development. Contact and social links are available on the project page.

FAQ

• What is Litho (deepwiki-rs)?
• An AI-powered documentation generation engine that analyzes source code and outputs comprehensive architecture documentation in the C4 model.
• What languages does Litho support?
• It supports multiple languages, including Rust, Python, Java, Go, C#, JavaScript, and more.
• What is the C4 model?
• A four-layer approach to software architecture documentation: Context, Container, Component, and Code diagrams.
• How do I install Litho?
• Use cargo install deepwiki-rs, or clone the repo and build from source.
• Can Litho integrate with CI/CD?
• Yes, Litho can be integrated into CI/CD pipelines to generate up-to-date documentation on every commit.
• Where can I get help?
• Documentation and issues are hosted on GitHub: the Litho/deepwiki-rs repository.

A Final Word

Litho represents a shift from manual, brittle documentation to automated, governance-friendly architecture knowledge. By leveraging AI-driven analysis, multi-language support, and a robust four-stage processing pipeline, Litho transforms a codebase into a living, navigable knowledge base. It helps teams reduce friction in onboarding, streamline code reviews, and ensure that architectural decisions stay visible and auditable as the project evolves. The ecosystem around Litho—Litho Book for consumption, Mermaid Fixer for diagram integrity, and seamless Git integration—rounds out a complete documentation workflow designed for modern software development.

Images in this post reflect key parts of the Litho ecosystem:

• Banner image:
• Litho Book snapshots:
• 
• 
• Mermaid Fixer snapshots:
• 
• 

If you’re looking to bring your codebase into a new era of maintainable, scalable, and readable documentation, Litho offers a compelling path forward—combining AI-driven insights, rigorous structure, and a practical workflow that fits right into modern development pipelines.