figurine and the case for random figlet fonts in your shell prompt

A prompt decoration, not a diagram tool

figurine describes itself in three words: print your name in style. The repository topics place it in the same family as figlet and lolcat, that is, terminal programs whose output is decorative rather than functional.

The scope is narrow in a useful way. You pass a message as arguments and the program renders it in a large block font. The project description in the README is explicit that every time the application is called it chooses a random font for rendering the message, and that the message you want to decorate is passed as arguments. There is no configuration file, no font selection remembered between runs, and no output format other than the rendered text.

The colour in the screenshot comes from somewhere else. The See Also section points to Rainbow, described as the library that colours the output, and the dependency is declared in the module file rather than vendored into this repository:

module github.com/arsham/figurine/v2

go 1.26.2

require github.com/arsham/rainbow/v2 v2.0.0

So figurine is the renderer and Rainbow is the painter. If you are evaluating the visual result, the colour behaviour lives in a project you would not otherwise pull in.

Random font selection is the behaviour, not a side effect

This is the design decision that decides whether you will like the tool. There is no seed, no flag to lock the font, and no persistent preference. The same command run twice gives two different typefaces.

That sounds like a gimmick, and for a tool used only in a shell prompt it is a reasonable one. The README suggests adding the program to a .zshrc or .bashrc file so that each time you open a new shell it shows a message, and explicitly says the application is very light weight, which is why that suggestion is offered. No measurement accompanies that claim, so treat it as a design intention rather than a figure to plan against.

The alternative reading is that randomness is a poor default for anything scripted. A message that changes shape on every run cannot be diffed, cannot be pasted into a bug report without looking different, and cannot be used in a CI log where a stable banner helps. In that setting, pinning the font is the behaviour you want, and the tool can do it, because a font can be named on the command line.

Installing the binary or building from source

Two routes are given. The first is a downloaded binary from the releases page of the repository, which is the sensible choice if you do not have a Go toolchain. The second is compiling from source with a single command:

go install github.com/arsham/figurine/v2@latest

The @latest suffix pulls the newest tagged version of the major version 2 module, and the go install command places the binary in the Go bin directory, so that directory has to be on your PATH.

The module file sets the required toolchain at go 1.26.2, which is the version line the source is written against. If your Go installation is older, the build is not a straightforward one, and the release binary route becomes the practical answer. The module path carries the /v2 suffix, which is how Go expresses a major version above one, so a project that depends on this library rather than the binary has to import github.com/arsham/figurine/v2 as well.

The repository also carries a Makefile with an install target that installs with -trimpath and with linker flags injecting the version and the current commit into the binary. That target is for a developer working on the project, not for a user, and the variables at the top of the file show that release binaries are built for amd64, arm and arm64 on Linux, amd64 and arm64 on macOS, and amd64 and arm64 on Windows.

Listing fonts and forcing one with -f

The documented commands are short enough to take in one reading. Listing the available fonts takes a flag, and the README shows it used in three shapes:

figurine -l
figurine -l -s
figurine -ls Sample Text

The plain form lists the fonts. The -s variant and the combined -ls form are shown in the same block, and the third example also renders a sample message, which is the practical way to preview candidates while you choose.

Choosing a specific font uses -f with the file name of the FIGlet font, including its extension:

figurine -f "Poison.flf" Some Text

The quoted name and the .flf extension matter. The fonts are the standard FIGlet font files, and the example shows the exact form the tool expects, so a name copied from the listing is the safest thing to pass.

The help flag is the last one documented:

figurine -h

It is worth running once, because the README's usage section only shows these four groups of flags, and a full flag list is exactly what a tool with this many rendering options should offer.

The build tooling reveals the development side of the project

The Makefile is more revealing about the project than the short README is. There is a lint target that runs go fmt, golangci-lint fmt, go vet and golangci-lint run over the module, and a dependencies target that installs the tools the maintainers use: reflex, golangci-lint v2, go-mod-outdated, goweight and govulncheck, followed by go mod tidy.

The unit test target runs go test in watch mode, driven by reflex, and it is configured with a timeout of 40s and a -short flag, so the project has a notion of a fast test subset. The command is wrapped in a zsh shell, and the reflex invocation watches Go files and go.mod for changes, which tells you the author develops on a Unix-like shell with zsh rather than a plain Windows environment.

The module also carries two indirect test dependencies, go-spew and go-difflib, pinned to specific pseudo versions, which is the usual shape for a Go project whose tests print diffs on failure. A .golangci.yml file at the root holds the lint configuration, and main_test.go sits next to main.go, so there is a test file at the top level for the command's own behaviour.

The license is Apache 2.0, stated both in the README and by a LICENSE file at the repository root, and the module path and repository URL in the go.mod file are the same github.com/arsham/figurine/v2 location that the install command uses.

Where figurine is the wrong choice

The first wrong choice is wanting output you control. If the font has to be the same on every run, the randomness has to be defeated by naming the font each time, and if the banner appears in a script or a CI job, a per invocation font is simply a bug. The tool is built for a human opening a shell, not for a program generating text.

The second is a need for a wider range of output. The fonts are FIGlet fonts, and the documented interface is a single message rendered in one of them. If you want to lay out a block of text, align columns, combine several fonts or export to a file, you need a different tool and this one will not grow into it.

The third is a build environment constraint. The module declares go 1.26.2, and the release binaries cover amd64 and arm64 on Linux, macOS and Windows, so a consumer on an older Go release or on a 32-bit platform has fewer options. The repository also has no homepage of its own, and the documentation is the README, so there is no separate user guide to consult for anything beyond the four commands shown above.

Compared with the original figlet, figurine changes the interaction model rather than the format. figlet is invoked with a font argument and renders deterministically; figurine randomises the font per call, adds colour through the Rainbow library, and ships as a Go module with a modern install path. If you want a deterministic banner with a font you choose, figlet is the more direct fit, and if you want a coloured random greeting every time you open a terminal, figurine is the one built for it.

Editorial conclusion

figurine suits a developer who wants a one line banner in the shell prompt and is happy to install a Go tool for it, since a single go install command and a line in .zshrc or .bashrc are the whole setup. It does not suit a team that needs deterministic output, a chosen font every time, or a programmatic banner API, because the random font selection is the default behaviour and the release binaries are the only distribution channel besides building from source. Before adopting it, list the fonts with figurine -l to see the size of the set, and check that Go 1.26.2 or newer is available if you intend to build rather than download.

Frequently asked questions

Official sources

1. arsham/figurine on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases