# DevTUI: a pile of small developer tools in one terminal interface

> DevTUI is a Go program that consolidates everyday developer utilities into a single terminal application, with a TUI for interactive use and a CLI for scripting. The interesting part is the dependency list, which reads as a catalogue of the formats it converts, and the documentation generator that writes the site from the code.

**skatkov/devtui** — A Swiss-army app for developers

- Repository: https://github.com/skatkov/devtui
- Website: https://devtui.com
- Stars: 556 · Forks: 29
- Language: Go
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/skatkov-devtui

## The pitch is consolidation, privacy and offline use

DevTUI is an all-in-one terminal toolkit that consolidates everyday developer utilities into a unified TUI and CLI interface, and the README calls it a Swiss-army app for developers.

The four reasons given are worth reading as a design brief. A unified experience, replacing scattered tools with a single app. Privacy-focused, because everything runs locally and no data ever leaves your computer. Offline support, because no internet is no problem. And built for the terminal, so there is no need to reach for your mouse or browser.

Those four are the reason to build something like this rather than the individual tools. A developer who converts JSON to YAML, or needs to base64 something, or wants to pretty print some XML, normally has a small collection of one-off scripts and a browser tab open. A single binary that does all of it and never makes a network call is a different proposition from a set of scripts, particularly on a machine where you would rather not paste data into a website.

The project is written in Go, MIT licensed, the default branch is main, the homepage is devtui.com, and the last push was on 2026-10-19. The release history shows 0.34.2 from 2026-03-15 and 0.34.1 from 2026-03-10, after v0.34.0 in January 2026, so the version is climbing through the thirties and the last release is a few months behind the last commit.

## Three install routes, and a FreeBSD port maintained by others

The install section offers a Homebrew tap, a FreeBSD package and a plain binary download.

```bash
brew install skatkov/tap/devtui
```

For FreeBSD, the README points at a port maintained by nice people in the FreeBSD ports tree, with the note that updates can take some time to propagate. That is a nice piece of evidence about the project, because a third party maintaining a package for you means the tool is being run on systems its author does not use.

```bash
pkg install devtui
```

And the third route is to download the executable from GitHub Releases.

The documentation entry point is devtui.com/start, and the README notes something about the FreeBSD port that applies to the project as a whole: the project is set up for a documented CLI and TUI, both of which are documented on the site.

The two interfaces are the point of the design. The TUI is the interactive mode, and the CLI is what you would put in a script or a shell alias, and the README's own build target names them, with a run target that starts the TUI in main mode and a separate production build for the other. Having both means the same functionality is reachable by keyboard-driven menu and by command line, and a unified interface for the CLI is what makes the tool usable from a pipeline.

## The dependency list is a list of formats

The go.mod is more informative than a feature list, because each direct dependency names a format or a capability the tool handles.

The terminal layer is the charm.land stack: bubbletea for the program model, bubbles for the components, lipgloss for styling, fang for the command line scaffolding, and huh for interactive forms. The older charmbracelet packages appear alongside them, with glamour for rendering markdown in the terminal, an editor component, a term helper, and go-runewidth for the layout arithmetic that wide characters need.

Then the format handlers. There is a JSON repair library from RealAlexandreAI, because a JSON tool that chokes on a trailing comma is not much use. The CSV side is clbanning/mxj for reading Excel spreadsheets, a csv2json internal package, and a converter package with YAML to JSON fuzz targets. For the config formats there is go-toml, yaml.v3, and go-xmlfmt alongside a CSS formatter. There is a GraphQL parser, a Go HTML parser, a cron expression library, a TOON format library, and xurls for extracting URLs from text.

The last group is the odds and ends. There is xdg for the config directory conventions, cobra for the command structure, go-isatty to detect a terminal, chroma for syntax highlighting, and a clipboard library. The presence of a cron library and a UUID library is the clearest signal of what kind of utilities are in there: the small tasks that a developer does repeatedly and that each otherwise deserve their own tiny tool.

## The documentation site is generated from the code

DevTUI includes automated documentation generators for both the CLI and TUI interfaces, and the README is careful to note that they are not complete yet.

To regenerate both sets of documentation:

```bash
cd docs && go run *.go
```

That run does several things. It generates CLI documentation in site/cli/ with proper Jekyll front matter, it generates TUI documentation in site/tui/ with key bindings and usage instructions, it cleans up the auto-generated content by removing footers and SEE ALSO sections, and it applies proper formatting and language hints for the code examples.

The individual generators can also be run separately, which is useful when you are working on one half of the tool:

```bash
# CLI documentation only
cd docs && go run cli-docs.go docs.go

# TUI documentation only
cd docs && go run tui-docs.go docs.go
```

So the documentation site is a build artefact, not a hand-maintained set of pages. The consequence is that a new command gets its reference page by running the generator rather than by writing markdown, which is why the site can cover a large number of small commands without a large number of pages to maintain.

The site itself is built with Jekyll, given the front matter in the output paths, and the repository has a site/ directory alongside the docs/ generator sources. The Makefile also has a docs target and a site target, so the generation is wired into the same command set as the build.

## The Makefile shows a project that fuzzes its parsers

The Makefile is where the engineering habits of the project become visible, and the target list is long: help, build, run, test, test-race, test-coverage, lint, fmt, vet, check, fuzz, fuzz-nightly, clean, deps, tidy, update-deps, generate, docs, site, release, snapshot, install, verify and all.

The build is a plain go build with version information injected through ldflags, where the version comes from git describe, the commit from git rev-parse, and the date from the current time, each passed into the cmd package as a separate symbol.

The test targets are worth noting. The default test target runs the suite verbosely and fails fast, and there is a separate race target that the README of the Makefile notes is what CI uses. The coverage target exists alongside.

Then there are the fuzz targets, which are the part that says something about the domain. The fuzz target runs a base64 round trip check and a check that the decoder matches standard library behaviour, a CSV to JSON check that the conversion does not panic, and a YAML to JSON check. The fuzz time is configurable, with a default of five seconds and a nightly default of forty five seconds, and the comment on the target says you can set FUZZTIME to 30s for deeper runs.

That is a sensible place to fuzz. A tool that converts between formats is a tool that will be handed malformed input, and the specific property being tested in each case is the right one, since the base64 target checks round tripping and the decoder against the standard library, the CSV target checks that it does not panic, and the YAML target checks the conversion.

## Conclusion

Adopt DevTUI if you want the small text utilities you reach for daily, such as format conversion, JSON tooling and encoding helpers, in one place that runs offline without a browser. Do not adopt it as a replacement for a serious data tool, since the utilities are convenience wrappers rather than a pipeline framework, and check which of the commands you need actually exist before you move your workflow onto it. Before you build from source, note that the tool requires Go 1.26.0, and that the documented TUI and CLI documentation on the site is generated from the code, so regenerating it after a change keeps the two in step.

## FAQ

### What is DevTUI?

It is an all-in-one terminal toolkit that consolidates everyday developer utilities into a unified TUI and CLI interface. The README highlights a unified experience instead of scattered tools, privacy since everything runs locally with no data leaving your computer, offline support, and a design built for the terminal.

### How do I install DevTUI?

With Homebrew using `brew install skatkov/tap/devtui`, with `pkg install devtui` on FreeBSD where the port is maintained by others, or by downloading the executable from the GitHub Releases page.

### How is the DevTUI documentation produced?

It is generated from the code. Run `cd docs && go run *.go` to regenerate the CLI pages under site/cli/ with Jekyll front matter and the TUI pages under site/tui/ with key bindings, cleaning up footers and applying formatting hints. The individual generators, cli-docs.go and tui-docs.go, can be run on their own.

### What does DevTUI do about testing its parsers?

The Makefile has fuzz targets for the base64 round trip and decoder behaviour against the standard library, for the CSV to JSON conversion not panicking, and for the YAML to JSON conversion, with a configurable fuzz time and a separate longer nightly setting.

## Sources

- [License: MIT](https://github.com/skatkov/devtui/blob/main/LICENSE)
- [Project website](https://devtui.com)
- [README](https://github.com/skatkov/devtui/blob/main/README.md)
- [Releases](https://github.com/skatkov/devtui/releases)
- [skatkov/devtui on GitHub](https://github.com/skatkov/devtui)

---

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