sabledocs

Sabledocs is a command-line generator for publishing static reference documentation from Protobuf and gRPC contracts. It is best for teams that own their contract build and want documentation produced locally or in CI, rather than for developers seeking an interactive service client. The zero-cost, open-source distribution is compelling, but its descriptor-based workflow and Python requirement make it a deliberate infrastructure choice.

Overview

Sabledocs turns a binary Protobuf descriptor into a static HTML site saved in sabledocs_output, with index.html as the entry point. That output can be deployed through whatever publishing process a team already uses, without a hosted documentation service. It can represent both Protobuf definitions and gRPC contracts, so a single reference site can cover an API surface that spans several packages.

The build is tightly coupled to protoc. A descriptor must be generated first, and Protobuf comments are included only when --include_source_info is passed. Teams that already control descriptor generation should find this predictable; projects without that pipeline must add and maintain another build step. Sabledocs is therefore a documentation tool, not a replacement for a gRPC requester, debugger, or API test console.

Key features

Multiple packages can be assembled into one documentation site, which is useful for organizations maintaining related contracts that would be awkward to publish separately. Search is enabled by default through a prebuilt Lunr index, giving readers client-side discovery without a hosted search backend.

Markdown works in the main content page and in Protobuf comments, allowing narrative guidance alongside generated members. Configuration in sabledocs.toml controls titles, input and output paths, package visibility, member ordering, comment filtering, and other generation choices. These settings make the output adaptable to house conventions instead of forcing a fixed presentation.

Jinja templates can be replaced for primary content, and additional templates can be added to the generated output. Source links can also be configured for model members, with GitHub, Bitbucket, Bitbucket Data Center, and GitLab repository types supported. An advanced hook can preprocess comments with a custom Python parser; that is useful for specialized comment formats, although the project warns that whitespace-sensitive formatting becomes harder to manage.

A Docker image bundles both protoc and Sabledocs. It provides a more reproducible build boundary for CI and reduces the need to provision those tools separately, while the regular installation path remains pip install sabledocs.

Pricing

Sabledocs — free. The free, open-source plan includes the static generator and requires Python 3.11 or later plus a Protobuf descriptor file. There are no paid tiers, seat charges, renewal terms, trial limits, or quota-based caps stated for this offering. It fits individual maintainers and teams that can self-host the generated site and manage their own build environment. Organizations wanting a vendor-managed service, support contract, or hosted publishing layer will need a different product or their own surrounding infrastructure.

Platforms

Sabledocs supports Linux, macOS, and Windows. It is self-hosted software: the generator runs in your environment, and the resulting files are opened or published from the generated directory. The Docker image is particularly relevant to Linux-based CI, while Python 3.11 or newer remains the runtime requirement for the package itself.

Who it's for

Choose Sabledocs when your team publishes Protobuf or gRPC contracts, already produces descriptors with protoc, and wants a repeatable static site from a local or CI build. Its multi-package output, configurable templates, source links, and built-in search suit internal platforms and public API references that need consistent navigation.

Look elsewhere if the primary job is sending RPC calls, inspecting live services, or maintaining interactive request history. Sabledocs also demands more pipeline ownership than a hosted documentation product: descriptor flags, Python versions, templates, and deployment are your responsibility.

Pros and cons

Pros

• Free and open source: there is no subscription, seat accounting, or renewal overhead for self-hosted use.
• Strong contract coverage: Protobuf and gRPC definitions from multiple packages can share one reference site.
• Practical customization: TOML settings, Jinja templates, extra templates, Markdown, comment filtering, ordering, and repository source links support tailored documentation.
• Build-friendly distribution: a Docker image includes both required command-line components, and the generated result is ordinary static HTML.

Cons

• Specific toolchain dependency: Python 3.11 or later and a binary descriptor are mandatory.
• Comment metadata is easy to omit: without --include_source_info, Protobuf comments do not reach the documentation.
• Self-hosting is part of the deal: publishing, runtime upkeep, and CI integration remain with the adopting team.
• Not an interactive client: it does not address workflows centered on calling or testing gRPC services.

Alternatives

Browse gRPC Tools for a broader category view. Pick gRPC CLI when you need unary RPC calls from a free, cross-platform command-line tool rather than generated documentation. grpcui is the better direction for an open-source, cross-platform web UI for interacting with services.

Kreya suits individuals wanting a freemium desktop client with request history, while protoc-gen-doc is a natural alternative when an MIT-licensed documentation generator is the priority. Choose Bandura for a free tool with personal and commercial use and no account, or FintX for an open-source client workflow with saved requests and multiple tabs. grpcmd is aimed at sending requests, starting a server, reflection, and scripting; ProtoCall is another freemium option with GitHub imports and manually created workspaces.

Verdict

Sabledocs is the right choice for teams that want free, self-hosted Protobuf and gRPC reference sites generated as part of a controlled build pipeline. Its strongest reasons to choose it are multi-package contract coverage and unusually broad output customization without a license bill. Look elsewhere if you need live RPC interaction, a managed publishing service, or a workflow that does not already produce protoc descriptors and run Python 3.11 or newer.