mrkeyoor.com_
Tue 01 Sept 17:39 UTC
Dev Toolsevaluationupdated 27 Aug 2026

usage review

Usage is a specification, command-line program, and Rust framework for defining a CLI once and reusing that definition for parsing, help, shell completions, man pages, Markdown, and generated SDKs. It solves the drift that appears when a tool's parser, documentation, and completion scripts are maintained separately.

+41stars / 7d
Verdict

Our npm run installed 274 packages in 35 seconds, then found no standard build or test target, so it verified the documentation toolchain's dependencies rather than the Rust product. Choose Usage when one CLI contract must feed help, completions, docs, SDKs, and agents. Keep clap for a conventional Rust-only program unless that portability justifies adopting an experimental framework and testing every supported shell.

We ran it

Lab card: what happened when we ran usageScreenshot of usage (usage.jdx.dev)
Install✓ · 35s274 packages · 351 MB
Buildn/ano build script
Testsn/ano test script
Known vulns50 critical · 3 high · 2 moderate · 0 low (npm audit)
Repo790 files~237,173 lines of source · 12.7 MB · 11 CI workflows · tests dir

Answers from our run

Does usage build from source?

Dependencies installed in 35 seconds (274 packages), and the project has no separate build step. We cloned commit 7927115 into a clean Debian container with 3 CPUs and no project-specific setup.

Does usage have tests you can run?

Not through a standard command: the project exposes no test script or target that our harness could run.

Does usage have known vulnerabilities in its dependencies?

npm audit flagged 5 known advisories in the dependency tree at the time of our run.

Who should not use usage?

Authors of deliberately unusual parsers: the specification documentation says Usage targets standard GNU-style options and cannot model every CLI.

What are the alternatives to usage?

clap, Cobra. Our npm run installed 274 packages in 35 seconds, then found no standard build or test target, so it verified the documentation toolchain's dependencies rather than the Rust product.

Setup4/5Several install routes, though adoption needs spec and release work
Docs5/5Detailed references for the spec, CLI, Rust, Go, and migration
Community4/5Fresh release, active pushes, and current issue discussion
Maturity4/5Established toolchain, but the Rust framework is experimental

Discussed on

  1. hnGraalVM 22.2: Smaller JDK size, improved memory usage, better library support48 points
  2. hnUsage – a shell completion / manpage / help documentation generator34 points
  3. hnJVM Host - Memory usage comparison of Java Application Servers and Applications15 points
  4. hnGraalVM 22.2: Smaller JDK size, improved memory usage, better library support8 points
  5. hnUsage Specification3 points

Who it’s for

CLI maintainers who publish help, documentation, man pages, and completions from one definition.
Rust teams willing to adopt a typed derive framework that can emit a portable KDL spec.
Authors of tools in other languages who want Usage to parse arguments or generate framework scaffolding.
Agent-tooling developers who need machine-readable command effects and output descriptions.

Who it’s NOT for

Authors of deliberately unusual parsers: the specification documentation says Usage targets standard GNU-style options and cannot model every CLI.
Rust teams that require strict point-release stability: the framework guide labels usage-rs experimental and says point releases may break.
clap applications built around runtime Command, ArgMatches, or CommandFactory: the migration guide says those APIs do not come across to Usage's typed model.
Shell users who cannot tolerate completion edge cases: open issue #712 reports zsh fallback completion inserting a literal *, while #684 reports permission errors on Fedora with Fish.
Small single-language CLIs that need only argument parsing: adopting KDL, a separate generator, and portable artifacts may add more machinery than they save.

Setup reality

At commit 7927115, npm installation succeeded in 35 seconds, adding 274 packages and using 351 MB. The root package had no standard build script or test script, so our harness skipped both steps. npm audit found 5 known vulnerabilities: 3 high and 2 moderate, with none critical or low.

That npm result covers the VitePress documentation toolchain, not a compiled Rust CLI. Users can install the released program through mise, Cargo, Homebrew, or Arch Linux. Rust adopters add the usage-rs crate; spec users also need to write or generate a KDL definition and decide which artifacts belong in their release process.

The repository contains 11 CI workflow files and a tests directory, but our Node-oriented sandbox found no npm test target and therefore ran no tests. Shell completion behavior still varies by shell and operating system, so teams should test generated scripts in every shell they claim to support.

One declaration for the whole CLI surface

Most command-line tools have several descriptions of the same interface. The parser knows the flags, the README has hand-written examples, a man page repeats the options, and every shell gets its own completion script. These copies drift. Usage puts commands, arguments, flags, environment variables, config files, outputs, and help into a KDL document that other tools can read.

The comparison to OpenAPI is useful. A Usage spec can generate Markdown, man pages, shell completions, JSON Schema, and client SDKs. It can also parse arguments for a program written in another language or scaffold definitions into supported frameworks. A binary may expose its own spec, allowing tooling to discover the interface instead of scraping --help output.

Recent additions make the spec especially interesting for coding agents. Commands can declare whether they read, write, or destroy state, and individual flags or arguments can raise that effect. Missing effect metadata means unknown, not safe. Output blocks can describe formats and exit codes. This is only descriptive metadata, not a security boundary, but it gives an agent or wrapper enough structure to ask before a destructive command and understand machine-readable output.

What happened when we ran it

We checked commit 7927115 in a fresh Debian container with 3 CPUs, 8 GB of RAM, Node 22, no secrets, and no elevated privileges. npm installation succeeded in 35 seconds, adding 274 packages and taking 351 MB on disk. The repository contained 790 files and about 237,173 lines of source.

The root npm package is for the VitePress documentation site. It has a docs:build command but no standard build target, so our harness skipped the build step. It also has no npm test target, so tests were skipped. This run did not compile or test the Rust workspace. That distinction matters because Usage itself is primarily Rust even though the sandbox selected the root Node package.

npm audit reported 5 known vulnerabilities: 3 high and 2 moderate. They belong to the installed Node dependency tree and should be assessed if you build or host the documentation. The repository also has a tests directory and 11 CI workflow files, which shows more engineering machinery than our npm-only path exercised. We cannot turn that presence into a passing test result from our run.

The Rust framework is capable and explicitly experimental

Rust developers can derive Cli on structs and enums, parse typed values, render help, and emit the same portable spec. Optional features cover completions, validation, configuration, response files, and test helpers. The project also documents a migration path from clap, including attribute replacements and differences in behavior.

The warning at the top of the Rust guide deserves attention: usage-rs is experimental, and point releases may break. This is not a small footnote for a parser, because argument behavior is part of a program's public interface. Pin the dependency, read release notes, and run CLI compatibility tests before updates.

Migration is easiest for clap applications already centered on derive macros. Programs using clap's runtime builder objects, ArgMatches, or CommandFactory need an architectural change because those pieces do not move into Usage's typed API. The guide also calls out differences in positional parsing, custom value parsing, default subcommands, and external subcommands. A compiler can catch type changes, but it cannot decide whether altered command behavior is acceptable to users.

Portability stops at unusual parsers and shell behavior

Usage aims at conventional GNU-style command lines. Its own specification guide says it cannot represent every possible CLI, and unusual option patterns may be rejected or warned about. Teams should model one real command before committing to a migration.

Shell completions are where portability meets messy host behavior. The project supports several shells, yet open reports document concrete edges. Issue #712 says generated zsh initialization can disturb fallback file completion and insert a literal asterisk. Issue #684 describes Fish completion initialization reading execute-only files on Fedora and printing permission errors. These reports do not erase the generator's value, but they make cross-shell testing part of adoption rather than an optional polish step.

For installation, users can choose mise, Cargo, Homebrew, or the Arch repository. Integrating the tool takes longer than installing it. A team must choose whether the KDL file or source-language declaration is authoritative, decide which generated artifacts are checked in, and add drift checks to CI. Without that ownership rule, one portable spec merely becomes another stale file.

Version 6.4.1 shipped alongside active issue work

The repository was pushed on August 26, 2026, and version 6.4.1 was released the same day. GitHub showed 29 open issues and pull requests combined, split into 24 issues and 5 pull requests by search. The release added terminal-aware help colors, adjusted negative-value parsing, hid marked commands from Markdown output, and lowered the published crates' minimum Rust version to 1.91.

Documentation is one of Usage's strongest reasons to try it. Separate guides cover the specification, CLI, Rust framework, Go binding, completions, migrations, and exact reference fields. The docs also state compatibility gaps instead of pretending every clap program or strange command syntax will fit.

Adopt Usage when the same CLI contract must serve humans, shells, SDK generators, and agents. For a small Rust binary that only needs parsing and help, clap remains the simpler default. Usage earns its extra concepts when generated artifacts and language-neutral introspection remove work you already have, not work you imagine having later.

Alternatives

ProjectWhat it isPick it when
clapA mature Rust command-line parser with derive and builder APIs.pick this instead when the CLI is Rust-only and parser stability or runtime builders matter more than a portable external specification.
Cobra gh↗A widely used Go framework for commands, flags, help, and completions.pick this instead when you are building a Go CLI and do not need one language-neutral definition to generate several artifacts.

What people are saying

  1. [github-trending] jdx/usage
  2. [lobsters] rust-glancer: An alternative LSP for Rust with focus on low memory usage
  3. [hackernews] AI usage patterns in software teams
  4. [github-trending] Willxup/cpa-usage-keeper
  5. [mastodon-trends] ‘DO NOT MENTION ALPR USAGE’: How Cops Are Trying to Hide Their Use of Flock
  6. [lobsters] Born Against, or why hobby programming communities are aggressively against LLM usage

Sources

  1. Usage repository
  2. Usage documentation
  3. Usage v6.4.1 release
  4. Open zsh completion report
  5. Open Fedora Fish completion report

More dev tools reviews

workmux · v2rayNG · SecLists · hashcat · eslint · fastfetch · the whole board →