HackDeepWiki

https://www.youtube.com/watch?v=tB1sC5bOQSw

HackDeepWiki turns any Git repository into an interactive, AI-generated wiki. Point it at a GitHub, GitLab, or Bitbucket repo (or a local folder) and it will:

1. Analyze the code structure
2. Generate structured documentation, page by page
3. Draw Mermaid diagrams of how things fit together
4. Let you chat with the repository (RAG-powered Q&A and multi-step Deep Research)

It ships as a single portable binary — an AppImage on Linux, a .exe on Windows — with no Docker, no database, and no mandatory API key: it works out of the box against a local Ollama install, and can also talk to OpenAI, Google Gemini, Anthropic Claude, OpenRouter, AWS Bedrock, Azure OpenAI, Alibaba Dashscope, or any OpenAI-compatible endpoint (Novita, Together, Groq, vLLM, LM Studio, and similar).

📱 HackDeepWikiReader is the companion read-only client app (Android/Linux/Windows) for browsing wikis and .zim archives from any HackDeepWiki server, or offline from an exported .hdwreader bundle — full chat parity (pick a provider/model, ask questions, Deep Research, 🔐 security-context) but no generation or scanning.

Features

• Automatic wiki generation for any public or token-authenticated GitHub / GitLab / Bitbucket repository, or a local directory.
• Visual architecture diagrams rendered with Mermaid, generated alongside the docs.
• Ask & Deep Research — a chat panel grounded in the repo's own code (RAG over embeddings), plus a multi-iteration research mode for harder questions.
• Code Editing mode (Devin-style) — flip the ⚙ toggle in the chat and an embedded opencode coding agent works directly on the local checkout of the repo: it reads, edits, runs commands and builds, full-auto. The chat goes fullscreen split-view — you keep talking on the left while its edits, diffs and shell output stream live in the right panel. It uses the same model you selected for the chat, knows the generated wiki (via MCP), and verifies the open wiki release matches the commit on disk before editing. The OpenCode binary ships inside the AppImage/exe; the in-app updater only installs the application-approved release after SHA-256 and executable checks, retaining the previous binary for rollback.
• Persistent memory (Engraphis) — every wiki release gets its own durable, explainable memory store powered by Engraphis (Apache-2.0, local-first, fully offline). The chat and the code-editing agent share it: decisions, preferences and findings survive across sessions, scoped strictly to that wiki version (never global). The full Engraphis dashboard is embedded right inside the app — the 🧠 Engraphis Memory button in the wiki sidebar opens the current release's memory, and the Evolution button next to the theme toggle opens a cross-release workspace that auto-records what changed between wiki versions (commit ranges, messages, diffstat). Everything lives in DATABASE/engraphis/engraphis.db — one portable SQLite file. Builds use the exact Engraphis commit locked in api/poetry.lock.
• Fully portable — download one file, run it, done. No containers, no services to stand up, no .env to hand-edit before your first run.
• Local-first by default — the packaged app auto-discovers a running Ollama instance and uses it for both generation and embeddings, so it works fully offline with zero API keys.
• Bring your own provider when you want cloud-grade models: OpenAI, Google Gemini, Anthropic Claude (API key or a Pro/Max subscription token from claude login), OpenRouter, AWS Bedrock, Azure OpenAI, Alibaba Dashscope, or any OpenAI-compatible API (Novita, Together, Groq, vLLM, LM Studio, etc.) via the custom-endpoint option.
• Multi-language wiki output with a language switcher in the UI.

Quick start — portable app (recommended)

1. Grab the latest build from the Releases page:
   • Linux → HackDeepWiki-x86_64.AppImage
   • Windows → HackDeepWiki-windows-x64.exe
2. Make it executable and run it (Linux: chmod +x HackDeepWiki-x86_64.AppImage && ./HackDeepWiki-x86_64.AppImage; Windows: just double-click it).
3. It starts its own local server, waits for it to come up, and opens your browser automatically at http://127.0.0.1:<port>.
4. Paste a repository URL and generate your first wiki. If you have Ollama running locally, no further setup is needed — otherwise open the model settings panel and add an API key for the provider of your choice.

Every push to main publishes its own neutral development pre-release, build-<run>-<commit>, so automatic builds never claim a product version, never overwrite each other, and remain directly linkable — the ten most recent are kept. Explicitly tagged commits publish the stable release under the exact tag chosen by the maintainer. Both platforms are built and attached automatically by .github/workflows/package.yml; the reusable release workflow only publishes artifacts that already passed their platform smoke tests.

Configuring a provider

Open the model/provider selector in the app and pick one of:

Provider	What you need
Ollama	Nothing — auto-detected at http://localhost:11434 if running.
OpenAI	An API key from the OpenAI platform dashboard.
Claude	An Anthropic API key, or a Claude Pro/Max subscription token from claude login (Claude Code CLI) — both are sent straight to api.anthropic.com with the right auth headers.
Google Gemini	A free API key from Google AI Studio.
OpenRouter / Bedrock / Azure / Dashscope	Credentials for that provider, entered in the same settings panel.
Custom (OpenAI-compatible)	Any OpenAI-compatible base URL (Novita, Together, Groq, vLLM, LM Studio, ...) plus its API key. Use the Reload button to fetch the model list from that endpoint.

Running from source

# Frontend
npm install
npm run dev            # http://localhost:3000

# Backend (separate terminal)
cd api
poetry install --only main
poetry run python -m api.main   # http://localhost:8001

The frontend proxies API/WebSocket calls to SERVER_BASE_URL (defaults to http://localhost:8001).

Building the portable binaries yourself

python -m pip install poetry==2.4.1
poetry -C api sync --with build --without dev
npm ci --legacy-peer-deps
npm run build
api/.venv/bin/python scripts/prepare_assets.py linux
api/.venv/bin/python -m PyInstaller hackdeepwiki.spec
scripts/package_appimage.sh
scripts/smoke_appimage.sh

This bundles the built Next.js frontend, the FastAPI backend, and a Node.js runtime into a single PyInstaller binary (scripts/launcher.py is the entrypoint), which the Linux job then wraps into an AppImage.

prepare_assets.py verifies the locked Engraphis 1.0.1 commit (memory engine + embedded dashboard); it never installs main or an ambient fallback during a build. It is installed without extras on purpose: the core is numpy-only and the dashboard reuses the already-bundled FastAPI/uvicorn, so the memory feature adds no heavy dependencies (no torch/sentence-transformers — recall runs offline on Engraphis's deterministic embedder). A missing or mismatched version aborts the build loudly.

Evolution backfill is deliberately bounded to the newest 2,000 reachable commits. Its stored marker and metadata report both the reachable total and truncated=true when that limit is hit, so a partial history is never presented as complete.

Operational and security references:

• Supported deployment model
• HTTP/WebSocket security matrix
• Backup, restore, health and diagnostics
• Dependency and packaged-component updates
• Security reporting policy

🤝 Contributing

Contributions are welcome:

• Open issues for bugs or feature requests
• Submit pull requests to improve the code
• Share feedback and ideas

📄 License

MIT License — see LICENSE for details.

⭐ Star History

🙏 Credits

This project is a fork of deepwiki-open by AsyncFuncAI. All credit for the original codebase goes to them.