# infinitered/gluegun: a TypeScript CLI toolkit that no longer adds features

> Gluegun bundles argument parsing, templating, filesystem work, prompts and printing into one toolbox for Node CLIs. Infinite Red has stopped adding features, so the decision is about stability and maintenance cost, not novelty.

**infinitered/gluegun** — GitHub describes it as A delightful toolkit for building TypeScript-powered command-line apps.. The repository metadata lists TypeScript as its primary language. The metadata lists the MIT license. This article stays within the project description and details documented in the GitHub repository README.

- Repository: https://github.com/infinitered/gluegun
- Stars: 3,145 · Forks: 155
- Language: TypeScript
- License: MIT
- Published: 2026-08-13 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/infinitered-gluegun

## The problem Gluegun solves for Node CLI authors

Writing a command-line tool in Node means assembling a parser, a help formatter, a prompt library, a template engine, a filesystem wrapper and a spinner before you write a single line of your actual tool. Gluegun ships those as one dependency. The README lists the bundled capabilities as parameters, template, patching, filesystem, system, http, prompt, print, semver, strings and packageManager, and says it also supports plugins and extensions. The audience is narrow and explicit: developers building a CLI app who want "powerful tools at your fingertips" without giving up flexibility. If your program is a library with one entry point, or a script you will run twice, the toolbox is more surface area than you need. The value shows up when the CLI has subcommands, prompts, generated files and coloured output, which is exactly the shape of the tools listed as users: Ignite CLI, Solidarity, Graph CLI and others.

## How the runtime, commands and toolbox fit together

A Gluegun CLI has three moving parts. The build function creates the runtime, the src directory holds commands, and each command receives a toolbox object. The README shows the wiring directly: build('movie') is given a name, .src(`${__dirname}/src`) points at the command directory, .plugins('node_modules', { matching: 'movie-*' }) loads plugins from installed packages, and .help(), .version() and .defaultCommand() add the standard behaviours before .create() and run(). A command is a plain object with a name, an optional alias and an async run function. Inside run, the toolbox is destructured into the pieces you need, so a command pulls in system, print, filesystem and strings only when it uses them. That destructuring is the design: the toolbox is the API surface, and the docs directory holds both the runtime notes and the toolbox API reference. Plugins are resolved by package name pattern rather than by a registry file, which means a plugin becomes active when it is installed in node_modules and matches the pattern you passed to .plugins().

## Installing Gluegun and running a first command

The README's Quick Start uses the published CLI to scaffold a project rather than adding Gluegun to an existing one. The command creates a directory named after the project, then asks whether you want TypeScript or modern JavaScript. After that you enter the folder, link the executable with yarn, and run the generated binary with its help subcommand. The README states you should see your new CLI help at that point.

```bash
npx gluegun new movies
cd movies
yarn link
movies help
```

The generated project contains a runtime entry point. The README gives this example of what that file looks like, using movie as the CLI name and movie-* as the plugin pattern.

```js
const { build } = require('gluegun')

const movieCLI = build('movie')
  .src(`${__dirname}/src`)
  .plugins('node_modules', { matching: 'movie-*' })
  .help()
  .version()
  .defaultCommand()
  .create()

movieCLI.run()
```

A command is a file under src/commands. The README example defines a command named foo with alias f, and destructures system, print, filesystem and strings from the toolbox inside run. Note the environment detail in that example: it reads process.env['HOME'] and writes a file into it. That is fine for a demo, and it is also the kind of path handling you should replace with the filesystem helpers before shipping on Windows.

## The maintenance model is the main constraint

The README carries a notice that Gluegun is at a stable point and that the maintainers are not planning new features, while still releasing community pull requests that cover performance, stability, types or similar enhancements. The Community Supported section repeats this: Infinite Red will not build new features, and encourages high quality pull requests, which it will try to review and merge in a timely manner. The last push to the repository was on 2025-11-24, and the most recent release in the same window was v5.2.2. Two of the last three releases, v5.2.1 and v5.2.2, landed within days of each other in November 2025, after v5.2.0 in August 2024. That pattern is consistent with the stated policy: occasional fixes and type or stability work, not a feature roadmap. For a team picking a CLI framework, this is the fact that should drive the decision. You are choosing a frozen API on purpose, or you are choosing a project whose direction you may have to influence yourself through pull requests.

## Where Gluegun is the wrong choice

The README itself points elsewhere for some cases. It lists Rust CLI, explaining that Rust offers speed and does not need a local Node engine, and it lists oclif as very actively maintained and used by large CLIs. It also notes that commander and yeoman have been around a long time with very large communities, and says Gluegun was built to avoid Commander and Yargs. Read that as a boundary rather than marketing. If your CLI must start in milliseconds or ship as a single static binary to machines without Node, the Node runtime is the wrong dependency and no amount of toolbox convenience fixes it. If you need a framework with an active feature roadmap and formal support expectations, oclif is the explicit alternative named in the same document. And if you only need argument parsing and a help screen, the bundled prompt, template, http and packageManager layers are weight you will carry without using. The Node.js 12.0+ requirement is also worth checking against your deployment targets, since that floor is stated in the README and older runtimes will not work.

## Gluegun compared with oclif

The difference is philosophical before it is technical. Gluegun hands you a toolbox object and a command object with a run function, and leaves the shape of your CLI to you; the README describes the goal as not giving up flexibility. oclif, which the README names as very actively maintained, is the opposite bet: a more opinionated framework with a maintained feature roadmap, used by large CLIs. Choosing between them is choosing whether you want a library of capabilities you compose, or a framework that decides more of the structure for you. The maintenance statements in the README make that trade explicit: with Gluegun you get a stable, feature-frozen toolbox and a community that merges fixes; with oclif you get a project that is still being developed. Neither is a quality claim. It is a question of whether your CLI needs to evolve with its framework or can sit on a fixed API for years.

## Licence and the cost of upgrading

Gluegun is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are included. That is a permissive, low-friction choice for a CLI you ship to customers or publish on npm. The upgrade cost follows from the maintenance model rather than the licence. Because the maintainers state they are not adding features, version bumps in the 5.x line are described as performance, stability and type work, so the risk of a breaking change arriving unannounced is lower than in a framework with an active roadmap. The counterpart is that a fix you need may not exist until someone in the community writes it. If your CLI depends on a plugin resolved through the .plugins('node_modules', { matching: ... }) pattern, check that pattern against your package naming before you rely on it, because a mismatch means the plugin silently does not load. This is a description of the licence terms as stated in the repository, not legal advice.

## Conclusion

Adopt Gluegun if you want a batteries-included toolbox for a Node CLI and you are comfortable with a project whose maintainer states it is no longer actively developed, with community pull requests still merged. Do not adopt it if you need new features, a long support commitment, or you are building in Rust or Go where the Node runtime is the wrong dependency. Before committing, verify that Node.js 12.0 or later is available in your target environments, read the runtime and toolbox API docs under docs/, and check whether the plugin matching pattern you plan to use is documented for your package layout.

## FAQ

### What is Gluegun good for?

It is a toolkit for building Node-based command-line interfaces in TypeScript or modern JavaScript. The README lists bundled support for parameters, templates, patching, filesystem work, running other commands, HTTP, prompts, printing, semver, strings and package installation.

### How do I install Gluegun and start a project?

The README's Quick Start runs npx gluegun new movies, chooses TypeScript or modern JavaScript, then changes into the folder, runs yarn link and runs movies help to see the generated CLI help.

### How do I use Gluegun in a command?

A command is an object with a name, an optional alias and an async run function. The run function receives the toolbox, and the README example destructures system, print, filesystem and strings from it.

### What is the difference between a glue gun and a hot glue gun?

This question is about physical hot glue guns, not the Gluegun CLI toolkit, and the repository material does not address it.

### How do I use a glue gun for the first time?

This question is about physical hot glue guns, not the Gluegun CLI toolkit, and the repository material does not address it.

## Sources

- [Official README](https://github.com/infinitered/gluegun#readme)
- [Project repository](https://github.com/infinitered/gluegun)
- [Release notes](https://github.com/infinitered/gluegun/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/infinitered-gluegun