Docs
Documentation that rebuilds itself.
Every commit updates the pages it touched. Every claim links to the line it came from. Nobody has to remember to write it.
Generated from verified structure, not from a summary of a summary.
Read a live wiki- parsed languages
- 16
- freshness cycle
- Every commit
- writing styles
- 4
- retrieval
- Hybrid
11 currently receive full-tier parsing and analysis depth.
Affected pages regenerate incrementally; the page reports freshness beside the content.
Comprehensive, reference, tutorial, and caveman over the same index.
Full-text and vector results fused with graph-aware expansion.
In plain words
Documentation written from the code, and rewritten when the code moves.
Every page is built from what the parser verified: symbols, imports, calls, history. A commit lands, the pages it touched regenerate, and every page shows how current it is and which lines each claim came from. Nobody has to remember to write it.
Retries
stale updating freshRetries the upstream call with exponential backoff.
why it is like this
The backoff is deliberate. Added after the 2024 outage.
How to read it
How current is this page?
- Fresh
- The code beneath the page has not changed since it was written. Read it as current.
- Stale
- Files it describes have had commits since. It is queued to regenerate; open the sources for anything that matters.
- Expired
- Too much has moved. The page is rebuilt before it is shown again.
- Cited
- Every claim links to a line range. The structure is deterministic; the sentences are a model's reading of it.
Sound familiar?
The docs were true once.
- 01
“The README describes the architecture from two years ago.”
- 02
“Nobody writes docs for the code that needs them most.”
- 03
“New joiners ask the same five questions every week.”
What you get
Read your codebase like a book that keeps itself current.
- Living pages
Module and file pages that regenerate when their code changes.
Only the pages a commit touched are rebuilt, usually a handful, in seconds.
- Freshness
Every page shows how current it is.
A page ages as the code beneath it moves and regenerates before it misleads anyone.
- Cited search
Ask a question, get an answer with its sources.
Full-text and semantic search fused, then expanded one hop along the graph.
- Your voice
Reference, tutorial, comprehensive or terse.
Pick the documentation style your team will actually read.
On a real repository
A page that says who wrote it, when, and from what.
This repository overview names the indexed repository, who or what wrote the content, when it changed, the architecture and entry points it describes, and the source records behind the passage you are reading.
Capture: Repowise documentation for the Repowise repository. Counts and paths in the image belong to that index state.
How it works
From symbols up to the whole repository.
The wiki is written bottom-up from what the parser verified, so a module page is grounded in the files beneath it rather than in a guess about them.
- 01 / Parse
Read every file as a tree
Symbols, imports, calls and docstrings across every supported language. - 02 / Write
Document from the bottom up
Symbols, then files, then modules, then the system, each page citing the level below. - 03 / Refresh
Rebuild only what changed
A commit lands, the affected pages regenerate, the rest stay untouched.
Where it shows up
What changes about your day.
Open any module or file and read its page, its freshness, its sources and the decisions that govern it. Ask a question from the chat dock on the page.
DashboardThe agent reads the same pages over MCP. A question about a module returns its page, cited, instead of a directory listing.
Coding agentsHover a symbol for its documentation. The walkthrough shows a new joiner the five files to start with.
VS Code
Honest limitations
Generated prose is a model's reading of verified structure.
The structure, citations and freshness are deterministic. The sentences are written by a model from that structure, so read a page's sources when the wording matters.
Common questions
Everything people ask before they try it.
Does the wiki go stale?
No. The wiki is rebuilt incrementally on every commit. Only the pages affected by a change regenerate, typically 3 to 10 pages, in seconds. Every page also carries a freshness and confidence score with git-informed decay, so when the code underneath a page changes the page ages and regenerates automatically instead of quietly drifting out of date.
Which languages are supported?
16 languages in total, with full-tier depth for 11 of them: Python, TypeScript, JavaScript, Java, Kotlin, Go, Rust, C++, C#, Scala, and Ruby. Full tier means AST parsing, import and call resolution, heritage extraction, docstrings, framework-aware edges, and code-health markers. C, Swift, PHP, and Dart are good tier, with more config and markup formats parsed beyond that.
Can I choose the writing style?
Yes. Wiki styles let you pick the documentation voice: comprehensive, reference, tutorial, or caveman. The same indexed graph and git history feed every style, so you can switch the tone of the generated pages without re-indexing the codebase.
How does search work?
Search over the wiki is hybrid RAG. Full-text and vector results are fused via reciprocal rank fusion, biased by PageRank so central code ranks higher, then expanded one hop along the dependency graph to pull in directly related pages. The result is a cited answer rather than a raw file dump, available in the dashboard and over MCP through get_answer and search_codebase.
Can I self-host it for private repos?
Yes, today. repowise is open source under AGPL-3.0 and runs fully self-hosted with pip install repowise, so the wiki for a private repo never leaves your infrastructure. You bring your own API key for generation, or run fully offline with a local embedding model. There is no waitlist and no logging into a competitor's agent to read your own docs.
How is it different from DeepWiki or Google Code Wiki?
DeepWiki and Google Code Wiki generate a snapshot wiki. repowise generates the wiki hierarchically from symbols up to files, modules, and the whole repo, then adds the four other intelligence layers around it: code health proven to predict real bugs, git risk and ownership, and architectural decision archaeology. It keeps the wiki fresh on every commit, and you can self-host it for private repos today.
Last reviewed: September 2026
Read your codebase like a book.
Index a public repository free and open the documentation it writes for itself.