gnux

command module
v0.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 11, 2026 License: MIT Imports: 3 Imported by: 0

README

gnux

Test Build Lint Go Reference

The GNU core utilities' interface, everywhere: one Go binary, a library and a portable shell. gnux is a portable, GNU-compatible implementation of the core utilities that brings their command-line interface (the same flags, semantics, diagnostics and exit statuses) to Linux, macOS, Windows, containers, the browser and Go programs, without needing GNU coreutils installed. Every tool is named after its GNU counterpart with an x appended (rm is rmx, cp is cpx, ls is lsx) and behaves like it.

gnux is an independent project. It is not affiliated with or endorsed by the GNU Project or the Free Software Foundation; it does not replace GNU coreutils, it makes their interface available wherever you work.

rmx -rf build/          # each tool is a command of its own…
gnux rmx -rf build/     # …and a subcommand of the one binary
// …and an importable engine…
err := rm.New(rm.Options{Recursive: true, Force: true}, core.Stdio()).Run([]string{"build"})
# …and a command in a script that runs the same on Linux, macOS and Windows.
gnux shell -c 'mkdirx -p dist && cpx -r assets dist/ && lsx -l dist'

Try it in the browser: the playground runs the real tools, compiled to WebAssembly, against an in-memory filesystem.

Tools

Tool GNU What it does
basenamex basename Strip directory and suffix from file names
catx cat Concatenate files and print them
cpx cp Copy files and directories
dirnamex dirname Strip the last component from file names
echox echo Print a line of text
envx env Run a program in a modified environment
falsex false Do nothing, unsuccessfully
headx head Print the first part of files
lnx ln Make hard and symbolic links
lsx ls List directory contents
mkdirx mkdir Create directories
mvx mv Move (rename) files
pwdx pwd Print the current working directory
realpathx realpath Print the resolved absolute path
rmx rm Remove files and directories
rmdirx rmdir Remove empty directories
sleepx sleep Pause for a given time
tailx tail Print the last part of files, optionally following
touchx touch Change file timestamps, creating files as needed
truex true Do nothing, successfully
wcx wc Count lines, words and bytes
yesx yes Print a string repeatedly

gnux --list prints the tool names; gnux --help lists them with a summary. The rest of coreutils is on the roadmap.

Requirements

To run gnux

  • Linux or macOS on amd64 or arm64, or Windows on amd64 (the platforms CI builds). The binary is statically linked (no cgo) and has no runtime dependencies - nothing else needs to be installed.
  • For the per-tool commands (rmx, cpx, …): a filesystem that supports symbolic links, and the install directory on your PATH. On Windows, creating symlinks needs Developer Mode or an elevated shell; copying gnux.exe to rmx.exe works just as well.

To install or build from source

  • Go 1.25 or newer (the version is pinned in go.mod).
  • git, for go install and for the version string stamped into source builds.
  • Optional: make for the Makefile targets, bash for install.sh, Docker for the image.

To work on the website (web/: documentation and playground)

  • Node.js 22.18 or newer and pnpm, plus Go to compile the tools to WebAssembly.

To use gnux as a library

  • A Go module on Go 1.25 or newer. The engines depend only on the standard library and github.com/mattn/go-isatty; cobra is compiled only into the command-line packages under cmd/.

To contribute

  • Everything above, plus golangci-lint v2 for make lint and make format, and lefthook for the Git hooks (make hooks installs them: format and lint on commit, a docs freshness check on push). make ci must pass, which includes regenerating documentation/.

Installation

Prebuilt binaries

Every tagged version is published as a GitHub release with an archive per platform (gnux-<version>-<os>-<arch>.tar.gz, .zip for Windows) and a checksums.txt:

v=v0.1.0
curl -LO "https://github.com/braswelljr/gnux/releases/download/$v/gnux-$v-linux-amd64.tar.gz"
curl -LO "https://github.com/braswelljr/gnux/releases/download/$v/checksums.txt"
sha256sum --check --ignore-missing checksums.txt
tar -xzf "gnux-$v-linux-amd64.tar.gz" && sudo mv "gnux-$v-linux-amd64/gnux" /usr/local/bin/
With go install
go install github.com/braswelljr/gnux@latest

This installs the gnux binary. To also get every tool as its own command, link the tool names to it (gnux looks at the name it was started under):

bin="$(dirname "$(command -v gnux)")"
for t in $(gnux --list); do ln -sf gnux "$bin/$t"; done
Install script
./install.sh                 # latest via `go install`, plus the per-tool links
./install.sh --from-source   # build from the current checkout
./install.sh --no-links      # the gnux binary only
From source
git clone https://github.com/braswelljr/gnux.git
cd gnux
make install/links   # install gnux and link every tool next to it
# or: make links && ./bin/lsx -la
Docker
docker build -t gnux .
docker run --rm -v "$(pwd):/work" gnux lsx -la
docker run --rm -v "$(pwd):/work" --entrypoint rmx gnux -rv build/
# or via compose:
docker compose run --rm gnux --version

Usage

As commands

Run a tool by its own name once linked, or through gnux:

lsx -la                           # list everything, long format
cpx -r src/ backup/               # copy a tree
mvx -i draft.md final.md          # rename, asking before overwriting
rmx -rf /tmp/cache                # unattended recursive delete
mkdirx -p a/b/c                   # create a path of directories
tailx -f app.log                  # follow a log
wcx -l *.go                       # count lines
envx -i PATH=/usr/bin mytool      # run with a clean environment

gnux lsx -la                      # the same tools as subcommands

Both forms also answer to the GNU name - gnux rm … works, and a link called rm behaves as rmx - so scripts written for the GNU tools run unchanged where GNU coreutils is not installed (Windows, minimal containers).

Every tool accepts --help and --version. Options follow GNU conventions: short flags combine (-rvf), long flags take --name=value, and -- ends option parsing.

Tools exit 0 on success and 1 when an operation fails, with a diagnostic on standard error prefixed by the tool name (rmx: cannot remove 'x': No such file or directory). A command-line mistake adds a pointer to --help. Tools whose status carries more meaning keep it: lsx exits 2 on serious trouble and envx uses 125–127.

As a portable shell

gnux shell is a small interpreter whose commands are the gnux tools, run inside the gnux process. Nothing in it depends on the system's own shell, so one script runs unchanged on every platform - the only thing a machine needs is the gnux binary.

gnux shell                       # interactive session
gnux shell -e build.gnux         # run a script, stopping at the first failure
gnux shell -c 'catx *.log | wcx -l'
# build.gnux
OUT=dist
rm -rf $OUT && mkdir -p $OUT/logs        # tools answer to their GNU names too
cp -r assets $OUT/
ls -1 $OUT | wc -l > $OUT/count.txt
cat $OUT/count.txt || echo "nothing built"

It understands a deliberately small subset of POSIX sh: pipelines, && / || / ;, redirection (<, >, >>), NAME=value variables with $NAME, ${NAME} and $?, single and double quotes, globbing, ~ and # comments, with the builtins cd, exit and help. There are no loops or functions, and external programs are reached through envx PROGRAM ….

As a library

Each tool's engine is an importable package under core/. An engine takes the options the flags would set plus the streams to read and write, and returns an error:

go get github.com/braswelljr/gnux
package main

import (
	"errors"
	"log"

	"github.com/braswelljr/gnux/core"
	"github.com/braswelljr/gnux/core/rm"
)

func main() {
	// rmx -rf build dist
	engine := rm.New(rm.Options{Recursive: true, Force: true}, core.Stdio())

	err := engine.Run([]string{"build", "dist"})
	if errors.Is(err, core.ErrFailed) {
		// Some paths could not be removed; the diagnostics already went to stderr.
		log.Fatal("cleanup incomplete")
	}
}
  • core.Stdio() wires an engine to the process's streams; core.Discard() silences it; or build a core.Streams from any io.Reader/io.Writer to capture output in a buffer.
  • Errors follow one convention: core.ErrFailed (ran, but something failed and was reported), *core.UsageError (bad arguments) and *core.ExitError (a specific exit status).
  • Engines expose injection points (PromptFn, RemoveFn, clocks, …) so the behavior that normally needs a terminal or a real filesystem can be driven from code.
  • To run a tool by name, call cmd.RunTool("rmx", args, streams); to run a whole portable script in-process, use cmd.NewShell(opts, streams).RunString(script).
  • To embed the entire command line, call cmd.Main(argv, streams): it returns the exit status rather than exiting.

API documentation: pkg.go.dev/github.com/braswelljr/gnux.

Workflows

Everyday use. Install once, link the tool names, and use rmx, cpx, lsx and the rest exactly as you would their GNU counterparts - including on Windows, where GNU coreutils is not usually installed.

Cross-platform scripting. Put the steps of a build, clean or packaging job in a script and run it with gnux shell -e. The same file serves a developer laptop and every CI runner.

Embedding. Import the engine you need from core/, hand it your own streams, and check the returned error against core.ErrFailed.

Contributing. Add an engine under core/ and its adapter under cmd/, register it in cmd/registry.go, then run make ci - vet, lint, tests, and regeneration of every generated doc. Commit the regenerated files with your change.

Continuous integration. Every push and pull request runs these GitHub workflows:

Workflow Checks
Test go vet and go test -race on Linux, macOS and Windows; a multi-call smoke test; the WebAssembly build
Build cross-compiles gnux for Linux, macOS and Windows and uploads the binaries
Lint golangci-lint
Docs regenerates documentation/ and web/content/docs/ and fails if the committed copies are stale
Web builds the WebAssembly binary, then lints, type-checks, tests and builds the website
Release on a v* tag: re-runs the checks, builds an archive per platform, publishes them with checksums and the tag's CHANGELOG.md section as notes

Documentation

The website in web/ - Fumadocs documentation plus the playground - is the friendliest way in: make web/dev serves it locally.

A full reference is also generated into documentation/ in markdown, man, YAML and reST, grouped by format so each directory is self-contained (documentation/markdown/ holds all markdown, etc.). The same content prints in the terminal with gnux help TOOL:

  • documentation/<format>/index.* - gnux itself (entry page, links to every tool)
  • documentation/<format>/guide.* - installation and usage guide
  • documentation/<format>/<tool>/index.* - one page per tool: description, permissions, use cases, flags, and examples for bash and PowerShell
  • documentation/<format>/<tool>/flags/<flag>.* - one page per flag, for tools that document them individually (rmx)
  • documentation/<format>/shell/index.* - the gnux shell

Hand-written documentation lives in docs/. The guides are also published on the website; the requirements, workflows and rules are for contributors and live here only:

Directory What it holds
documentation/guides/ Getting started, a cookbook of recipes, portable scripting, Windows and PowerShell, CI and containers, the Go library, adoption next to GNU coreutils, troubleshooting
docs/requirements/ The SRS and the business, functional and non-functional requirement registers
docs/workflows/ How each process runs inside the code: dispatch, engines, the shell, docs, CI and releases
docs/rules/ The rules the code follows, each with its reasoning and how it is checked

docs/README.md is the map of all of it.

Start at documentation/markdown/index.md. The website's pages (web/content/docs/) are generated from the same source. Regenerate everything with make docs (or go generate ./...).

Development

make build        # build ./bin/gnux (version injected via ldflags)
make links        # build, then link every tool name in ./bin
make test         # go test -race ./...
make cover        # tests + coverage.out summary
make lint         # golangci-lint
make format       # format everything: Go (gofmt -s + goimports) and the website (Prettier)
make hooks        # install the lefthook Git hooks (lefthook.yml)
make docs         # regenerate documentation/ and web/content/docs/
make ci           # vet + lint + test + docs freshness check
make web/dev      # build the wasm + docs content, then serve the website locally
make web/test     # test the playground's filesystem against the real wasm
make web/build    # production build of the website
make help         # list all targets

Each tool is two packages: an engine in core/<tool>/ holding all the behavior, and a thin adapter in cmd/<tool>x/ that declares the flags and the documentation. One registry (cmd/registry.go) feeds the root command, the name-based dispatch and the doc generator. See AGENTS.md for the architecture, conventions, and how to add a tool.

Roadmap

Not yet implemented, roughly in priority order:

  • File attributes: chmod, chown, chgrp, stat, du, df, mktemp, install, truncate, readlink, link, unlink
  • Text: sort, uniq, cut, tr, tee, paste, join, nl, fold, fmt, expand, unexpand, tac, split, csplit, comm, shuf, seq, printf, od
  • Checksums and encoding: md5sum, sha1sum, sha256sum, sha512sum, b2sum, cksum, base32, base64
  • System: date, uname, whoami, id, hostname, nproc, printenv, tty, who, uptime, timeout, nice, nohup, kill, test, expr, dd

License

See LICENSE.

Documentation

Overview

Command gnux is a multi-call binary carrying GNU-compatible implementations of the core utilities, for every platform. See package cmd for how a tool is selected.

Directories

Path Synopsis
cmd
Package cmd assembles the gnux multi-call binary: a root command carrying one subcommand per tool, and a dispatcher that runs a tool directly when the binary is invoked under that tool's name.
Package cmd assembles the gnux multi-call binary: a root command carrying one subcommand per tool, and a dispatcher that runs a tool directly when the binary is invoked under that tool's name.
basenamex
Package basenamex wires the basenamex command (GNU basename) to its engine.
Package basenamex wires the basenamex command (GNU basename) to its engine.
catx
Package catx wires the catx command (GNU cat) to its engine.
Package catx wires the catx command (GNU cat) to its engine.
cpx
Package cpx wires the cpx command (GNU cp) to its copy engine.
Package cpx wires the cpx command (GNU cp) to its copy engine.
dirnamex
Package dirnamex wires the dirnamex command (GNU dirname) to its engine.
Package dirnamex wires the dirnamex command (GNU dirname) to its engine.
docs
Package docs generates reference documentation for gnux and every tool it ships, in each format cobra supports (markdown, man, yaml, reST).
Package docs generates reference documentation for gnux and every tool it ships, in each format cobra supports (markdown, man, yaml, reST).
echox
Package echox wires the echox command (GNU echo) to its engine.
Package echox wires the echox command (GNU echo) to its engine.
envx
Package envx wires the envx command (GNU env) to its engine.
Package envx wires the envx command (GNU env) to its engine.
falsex
Package falsex implements the falsex command (GNU false).
Package falsex implements the falsex command (GNU false).
headx
Package headx wires the headx command (GNU head) to its engine.
Package headx wires the headx command (GNU head) to its engine.
lnx
Package lnx wires the lnx command (GNU ln) to its link engine.
Package lnx wires the lnx command (GNU ln) to its link engine.
lsx
Package lsx wires the lsx command (GNU ls) to its listing engine.
Package lsx wires the lsx command (GNU ls) to its listing engine.
mkdirx
Package mkdirx wires the mkdirx command (GNU mkdir) to its engine.
Package mkdirx wires the mkdirx command (GNU mkdir) to its engine.
mvx
Package mvx wires the mvx command (GNU mv) to its move engine.
Package mvx wires the mvx command (GNU mv) to its move engine.
pwdx
Package pwdx wires the pwdx command (GNU pwd) to its engine.
Package pwdx wires the pwdx command (GNU pwd) to its engine.
realpathx
Package realpathx wires the realpathx command (GNU realpath) to its engine.
Package realpathx wires the realpathx command (GNU realpath) to its engine.
rmdirx
Package rmdirx wires the rmdirx command (GNU rmdir) to its engine.
Package rmdirx wires the rmdirx command (GNU rmdir) to its engine.
rmx
Package rmx wires the rmx command (GNU rm) to its removal engine.
Package rmx wires the rmx command (GNU rm) to its removal engine.
rmx/directory
Package directory implements rm's -d/--dir flag: remove empty directories.
Package directory implements rm's -d/--dir flag: remove empty directories.
rmx/force
Package force implements rm's -f/--force flag: ignore nonexistent files and arguments, never prompt, and suppress the resulting errors.
Package force implements rm's -f/--force flag: ignore nonexistent files and arguments, never prompt, and suppress the resulting errors.
rmx/interactive
Package interactive implements rm's prompting flags: -i (prompt before every removal), -I (prompt once before a bulk or recursive removal) and --interactive[=WHEN].
Package interactive implements rm's prompting flags: -i (prompt before every removal), -I (prompt once before a bulk or recursive removal) and --interactive[=WHEN].
rmx/onefilesystem
Package onefilesystem implements rm's --one-file-system flag: when removing a hierarchy recursively, skip any directory on a different file system than the one the removal started on.
Package onefilesystem implements rm's --one-file-system flag: when removing a hierarchy recursively, skip any directory on a different file system than the one the removal started on.
rmx/preserveroot
Package preserveroot implements rm's --preserve-root / --no-preserve-root flags, the failsafe that refuses to recurse on the filesystem root '/'.
Package preserveroot implements rm's --preserve-root / --no-preserve-root flags, the failsafe that refuses to recurse on the filesystem root '/'.
rmx/recursive
Package recursive implements rm's -r/-R/--recursive flag: remove directories and their contents recursively.
Package recursive implements rm's -r/-R/--recursive flag: remove directories and their contents recursively.
rmx/verbose
Package verbose implements rm's -v/--verbose flag: report each removal.
Package verbose implements rm's -v/--verbose flag: report each removal.
sleepx
Package sleepx wires the sleepx command (GNU sleep) to its engine.
Package sleepx wires the sleepx command (GNU sleep) to its engine.
tailx
Package tailx wires the tailx command (GNU tail) to its engine.
Package tailx wires the tailx command (GNU tail) to its engine.
touchx
Package touchx wires the touchx command (GNU touch) to its engine.
Package touchx wires the touchx command (GNU touch) to its engine.
truex
Package truex implements the truex command (GNU true).
Package truex implements the truex command (GNU true).
wcx
Package wcx wires the wcx command (GNU wc) to its engine.
Package wcx wires the wcx command (GNU wc) to its engine.
yesx
Package yesx wires the yesx command (GNU yes) to its engine.
Package yesx wires the yesx command (GNU yes) to its engine.
Package core holds the plumbing every gnux engine shares: the standard streams, GNU-style diagnostics, exit-status errors and confirmation prompts.
Package core holds the plumbing every gnux engine shares: the standard streams, GNU-style diagnostics, exit-status errors and confirmation prompts.
basename
Package basename implements the engine behind basenamex, a GNU-compatible implementation of the GNU/UNIX basename command: strip the directory and, optionally, a trailing suffix from file names.
Package basename implements the engine behind basenamex, a GNU-compatible implementation of the GNU/UNIX basename command: strip the directory and, optionally, a trailing suffix from file names.
cat
Package cat implements the engine behind catx, a GNU-compatible implementation of the GNU/UNIX cat command: concatenate files to standard output, optionally numbering lines and making invisible characters visible.
Package cat implements the engine behind catx, a GNU-compatible implementation of the GNU/UNIX cat command: concatenate files to standard output, optionally numbering lines and making invisible characters visible.
cp
Package cp implements the copy engine behind cpx, a GNU-compatible implementation of the GNU/UNIX cp command.
Package cp implements the copy engine behind cpx, a GNU-compatible implementation of the GNU/UNIX cp command.
dirname
Package dirname implements the engine behind dirnamex, a GNU-compatible implementation of the GNU/UNIX dirname command: strip the last component from file names.
Package dirname implements the engine behind dirnamex, a GNU-compatible implementation of the GNU/UNIX dirname command: strip the last component from file names.
echo
Package echo implements the engine behind echox, a GNU-compatible implementation of the GNU/UNIX echo command: write the operands, separated by single spaces and followed by a newline, to standard output.
Package echo implements the engine behind echox, a GNU-compatible implementation of the GNU/UNIX echo command: write the operands, separated by single spaces and followed by a newline, to standard output.
env
Package env implements the engine behind envx, a GNU-compatible implementation of the GNU/UNIX env command: print the environment, or run a command in a modified one.
Package env implements the engine behind envx, a GNU-compatible implementation of the GNU/UNIX env command: print the environment, or run a command in a modified one.
head
Package head implements the engine behind headx, a GNU-compatible implementation of the GNU/UNIX head command: print the first part of each file.
Package head implements the engine behind headx, a GNU-compatible implementation of the GNU/UNIX head command: print the first part of each file.
ln
Package ln implements the engine behind lnx, a GNU-compatible implementation of the GNU/UNIX ln command: make hard or symbolic links between files.
Package ln implements the engine behind lnx, a GNU-compatible implementation of the GNU/UNIX ln command: make hard or symbolic links between files.
ls
Package ls implements the engine behind lsx, a GNU-compatible implementation of the GNU/UNIX ls command: list information about files and the contents of directories.
Package ls implements the engine behind lsx, a GNU-compatible implementation of the GNU/UNIX ls command: list information about files and the contents of directories.
mkdir
Package mkdir implements the engine behind mkdirx, a GNU-compatible implementation of the GNU/UNIX mkdir command: create directories, optionally with their parents and an explicit mode.
Package mkdir implements the engine behind mkdirx, a GNU-compatible implementation of the GNU/UNIX mkdir command: create directories, optionally with their parents and an explicit mode.
mv
Package mv implements the engine behind mvx, a GNU-compatible implementation of the GNU/UNIX mv command.
Package mv implements the engine behind mvx, a GNU-compatible implementation of the GNU/UNIX mv command.
pwd
Package pwd implements the engine behind pwdx, a GNU-compatible implementation of the GNU/UNIX pwd command: print the name of the current working directory.
Package pwd implements the engine behind pwdx, a GNU-compatible implementation of the GNU/UNIX pwd command: print the name of the current working directory.
realpath
Package realpath implements the engine behind realpathx, a GNU-compatible implementation of the GNU realpath command: print the resolved absolute name of each file.
Package realpath implements the engine behind realpathx, a GNU-compatible implementation of the GNU realpath command: print the resolved absolute name of each file.
rm
Package rm implements the removal engine behind rmx, a GNU-compatible implementation of the GNU/UNIX rm command.
Package rm implements the removal engine behind rmx, a GNU-compatible implementation of the GNU/UNIX rm command.
rmdir
Package rmdir implements the engine behind rmdirx, a GNU-compatible implementation of the GNU/UNIX rmdir command: remove directories, but only if they are empty.
Package rmdir implements the engine behind rmdirx, a GNU-compatible implementation of the GNU/UNIX rmdir command: remove directories, but only if they are empty.
shell
Package shell implements the gnux shell: a small, portable command interpreter whose commands are the gnux tools, run in-process.
Package shell implements the gnux shell: a small, portable command interpreter whose commands are the gnux tools, run in-process.
sleep
Package sleep implements the engine behind sleepx, a GNU-compatible implementation of the GNU/UNIX sleep command: pause for the sum of the given time intervals.
Package sleep implements the engine behind sleepx, a GNU-compatible implementation of the GNU/UNIX sleep command: pause for the sum of the given time intervals.
tail
Package tail implements the engine behind tailx, a GNU-compatible implementation of the GNU/UNIX tail command: print the last part of each file and, with --follow, keep printing what is appended to it.
Package tail implements the engine behind tailx, a GNU-compatible implementation of the GNU/UNIX tail command: print the last part of each file and, with --follow, keep printing what is appended to it.
touch
Package touch implements the engine behind touchx, a GNU-compatible implementation of the GNU/UNIX touch command: update the access and modification times of files, creating the ones that do not exist.
Package touch implements the engine behind touchx, a GNU-compatible implementation of the GNU/UNIX touch command: update the access and modification times of files, creating the ones that do not exist.
wc
Package wc implements the engine behind wcx, a GNU-compatible implementation of the GNU/UNIX wc command: print line, word, character and byte counts for each file.
Package wc implements the engine behind wcx, a GNU-compatible implementation of the GNU/UNIX wc command: print line, word, character and byte counts for each file.
yes
Package yes implements the engine behind yesx, a GNU-compatible implementation of the GNU/UNIX yes command: print a line over and over until the reader goes away.
Package yes implements the engine behind yesx, a GNU-compatible implementation of the GNU/UNIX yes command: print a line over and over until the reader goes away.
internal
common
Package common holds app-wide constants shared across packages.
Package common holds app-wide constants shared across packages.
docmeta
Package docmeta defines the documentation metadata that every tool (and, where a tool documents them individually, every flag) exposes.
Package docmeta defines the documentation metadata that every tool (and, where a tool documents them individually, every flag) exposes.
tool
Package tool defines what a gnux tool is - its metadata, flags and entry point - and turns that description into a cobra command.
Package tool defines what a gnux tool is - its metadata, flags and entry point - and turns that description into a cobra command.
tools
changelog command
Command changelog prints the CHANGELOG.md section of one release, for the release workflow to publish as that release's notes.
Command changelog prints the CHANGELOG.md section of one release, for the release workflow to publish as that release's notes.
gendocs command
Command gendocs generates the gnux reference - the entry page, the guide and one page per tool (and per flag, where a tool documents them) - in every cobra format.
Command gendocs generates the gnux reference - the entry page, the guide and one page per tool (and per flag, where a tool documents them) - in every cobra format.
wasm command
Command wasm is the WebAssembly build of gnux that powers the web playground.
Command wasm is the WebAssembly build of gnux that powers the web playground.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL