A folder in your repository becomes the docs in the project.
You write your software's documentation where it belongs: as files in your repository, by default in the folder .lalabase/doku/. You connect that folder to the project and Lalabase keeps it current on each sync. The repository stays the single source of truth, the project holds a readable copy. Clients and external developers join as guests in the project so they can read exactly these pages.
- 01 One folder in the repository, readable in the project under Documentation
- 02 The sync runs one way: you change things in the repository, never in Lalabase
- 03 Pages that changed since the last visit are flagged, so your client can see what was added
- 04 Several documentation sets per project, for example a manual and a change log kept apart
- 05 The documentation pages are available to the project chat as a source. When your client asks in the chat, the answer comes out of your own documentation
- 06 On top of that the source code can be indexed. What gets searched then is not the file name, but the structure of the code
How this works
GitHub or GitLab, one access token, done. The project then knows where its source code lives and which branch is the authoritative one.
The default is `.lalabase/doku/`. Every markdown file in it becomes a page, and the folder structure becomes the outline.
In the editor, on a branch, in a pull request, with review. The documentation does not age separately from the code, because it sits next to it and is reviewed with it.
Whoever has no repository access still reads it. Every page carries the commit it came from, and the project chat answers questions from it with sources.
What it does not do
Three limits that follow from that direction.
- A one-way street. Lalabase reads the repository and writes nothing into it. The documentation is edited where it lives.
- GitHub and GitLab only. A self-hosted Git server is not connected today.
- Markdown only. Whatever else sits in the folder stays there.
What people ask at this point
- What happens when someone changes something in the repository?
- The state is pulled in, and every page knows which commit it came from. So you see not only the text but also how old it is.
- Does everyone on the team need repository access?
- No, and that is the point. The access sits with the project, once. Whoever should read the documentation gets read rights in the project, not on GitHub.
- Why no wiki inside the application?
- Because then the documentation exists twice. A wiki beside the repository is, half a year later, the version nobody trusts any more. For notes that do not belong to the code there are notes in the project.
Look at it
rather than take our word for it.
Productive in under 5 minutes. No sales loop.
Particular data protection or compliance requirements? Talk to us. For cases like that we usually find a way.