gnux

command module
v1.3.0 Latest Latest
Warning

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

Go to latest
Published: Oct 21, 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
archx arch Print machine architecture
b2sumx b2sum Print or check BLAKE2b (512-bit) checksums
base32x base32 Encode or decode data in base32
base64x base64 Encode or decode data in base64
basenamex basename Strip the directory and suffix from file names
basencx basenc Encode or decode data in base64, base64url, base32, base32hex, base16, base2 or Z85
catx cat Concatenate files and print them on standard output
chgrpx chgrp Change group ownership
chmodx chmod Change file mode bits
chownx chown Change file owner and group
cksumx cksum Print or check checksums and byte counts
commx comm Compare two sorted files line by line
cpx cp Copy files and directories
csplitx csplit Split a file into sections determined by context lines
cutx cut Remove sections from each line of files
datex date Print the date and time
ddx dd Convert and copy a file, block by block
dfx df Report file system space usage
dircolorsx dircolors Print commands that set LS_COLORS, the colors of lsx --color
dirnamex dirname Strip the last component from file names
dirx dir List directory contents in columns
dux du Estimate file space usage
echox echo Display a line of text
envx env Run a program in a modified environment, or print the environment
expandx expand Convert tabs to spaces
exprx expr Evaluate an expression and print its value
factorx factor Print the prime factors of each number
falsex false Do nothing, unsuccessfully
findx find Search for files in a directory hierarchy
fmtx fmt Reformat each paragraph of text
foldx fold Wrap each input line to fit in a specified width
grepx grep Print the lines that match patterns
groupsx groups Print the groups a user is in
headx head Print the first part of each file
hostidx hostid Print the numeric identifier for the current host
hostnamex hostname Print the name of the current host system
idx id Print real and effective user and group IDs
installx install Copy files into place and set their mode, owner and group
joinx join Join lines of two files on a common field
killx kill Send a signal to processes, or list signals
linkx link Call the link function to create a hard link to a file
lnx ln Make hard or symbolic links between files
lognamex logname Print the user's login name
lsx ls List information about files and directory contents
md5sumx md5sum Print or check MD5 (128-bit) checksums
mkdirx mkdir Create the DIRECTORY(ies), if they do not already exist
mkfifox mkfifo Make named pipes (FIFOs)
mknodx mknod Make block or character special files, or named pipes
mktempx mktemp Create a temporary file or directory, safely, and print its name
mvx mv Move (rename) files and directories
nicex nice Run a program with modified scheduling priority
nlx nl Number lines of files
nohupx nohup Run a command immune to hangups, with output to a non-terminal
nprocx nproc Print the number of processing units available
numfmtx numfmt Convert numbers to and from human-readable strings
odx od Dump files in octal and other formats
pastex paste Merge lines of files
pathchkx pathchk Check whether file names are valid or portable
pinkyx pinky Show who is logged in, or what is known about users
printenvx printenv Print all or part of the environment
printfx printf Format and print data
prx pr Paginate or columnate files for printing
ptxx ptx Produce a permuted index of the words in a text
pwdx pwd Print the full name of the current working directory
readlinkx readlink Print resolved symbolic links or canonical file names
realpathx realpath Print the resolved absolute file name
rmdirx rmdir Remove the DIRECTORY(ies), if they are empty
rmx rm Remove (unlink) files and directories
sedx sed Filter and transform text with a stream editor
seqx seq Print a sequence of numbers
sha1sumx sha1sum Print or check SHA-1 (160-bit) checksums
sha224sumx sha224sum Print or check SHA-224 (224-bit) checksums
sha256sumx sha256sum Print or check SHA-256 (256-bit) checksums
sha384sumx sha384sum Print or check SHA-384 (384-bit) checksums
sha512sumx sha512sum Print or check SHA-512 (512-bit) checksums
shredx shred Overwrite a file to hide its contents, and optionally delete it
shufx shuf Generate random permutations
sleepx sleep Delay for a specified amount of time
sortx sort Sort lines of text files
splitx split Split a file into pieces
statx stat Display file or file system status
stdbufx stdbuf Run a command with modified buffering of its standard streams
sttyx stty Print or change terminal line settings
sumx sum Print the checksum and block count of each file
syncx sync Synchronize cached writes to persistent storage
tacx tac Concatenate and print files in reverse
tailx tail Print the last part of each file, optionally following it as it grows
teex tee Copy standard input to each FILE, and also to standard output
testx test Check file types and compare values
timeoutx timeout Run a command with a time limit
touchx touch Update the access and modification times of each FILE to the current time
truex true Do nothing, successfully
truncatex truncate Shrink or extend the size of each FILE to the specified size
trx tr Translate, squeeze, and/or delete characters from standard input
tsortx tsort Perform a topological sort
ttyx tty Print the file name of the terminal connected to standard input
unamex uname Print system information
unexpandx unexpand Convert spaces to tabs
uniqx uniq Report or omit repeated lines
unlinkx unlink Call the unlink function to remove the specified file
uptimex uptime Tell how long the system has been running
usersx users Print the user names of users currently logged in
vdirx vdir List directory contents in the long format
wcx wc Print newline, word, and byte counts for each file
whoamix whoami Print the user name associated with the current effective user ID
whox who Show who is logged on
xargsx xargs Build and run command lines from standard input
yesx yes Output a string repeatedly until killed

gnux --list prints the tool names; gnux --help lists them with a summary. Every GNU coreutils tool is here except the three the roadmap leaves out by design.

Four of the tools are not part of GNU coreutils: grepx (GNU grep), sedx (GNU sed), and findx and xargsx (GNU findutils). They are here because a build or CI script rarely stays inside coreutils: the first find . -name '*.map' | xargs rm or sed -i would otherwise send it back to the system's own tools, which differ between Linux, macOS and Windows.

Requirements

To run gnux

  • Linux on amd64, arm64 or riscv64, macOS or FreeBSD on amd64 or arm64, or Windows on amd64 or arm64 (the platforms CI builds and releases). 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.26 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.26 or newer. The engines depend only on the standard library, github.com/mattn/go-isatty, golang.org/x/sys (system calls the standard library does not wrap, on Windows and the BSDs) and golang.org/x/crypto (BLAKE2b), all pure Go; 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). make ci must pass, which includes generating the reference.

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=v1.2.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/
Package managers

From v0.0.2 on, each release is also published to Homebrew (macOS and Linux), Scoop and winget (Windows), the Snap Store and the AUR (Linux):

brew tap braswelljr/gnux https://github.com/braswelljr/gnux
brew install --cask braswelljr/gnux/gnux   # also installs bash, zsh and fish completion
scoop bucket add gnux https://github.com/braswelljr/gnux
scoop install gnux/gnux
winget install braswelljr.gnux
sudo snap install gnux                     # strictly confined: your home directory only
yay -S gnux-bin                            # Arch Linux, from the AUR

and carries a .deb, an .rpm and an .apk for amd64, arm64 and riscv64:

v=v1.2.0
curl -LO "https://github.com/braswelljr/gnux/releases/download/$v/gnux-$v-linux-amd64.deb"
sudo dpkg -i "gnux-$v-linux-amd64.deb"                        # Debian, Ubuntu
sudo rpm -i "gnux-$v-linux-amd64.rpm"                         # Fedora, RHEL, openSUSE
sudo apk add --allow-untrusted "gnux-$v-linux-amd64.apk"      # Alpine

These install the gnux binary; link the tool names to it as shown under go install below, or run each tool as gnux rmx .... A package manager shows up a little after the release it belongs to, winget last, since each new version is reviewed there.

npm

In a Node project, gnux is a development dependency. It installs the native binary for the machine, from a package of its own per platform, and puts every tool on the PATH of the package scripts, so one dependency replaces rimraf, mkdirp, cpy-cli, shx and cross-env:

npm install --save-dev gnux
{ "scripts": { "clean": "rmx -rf dist", "prebuild": "mkdirx -p dist", "build": "cpx -r public/. dist/" } }

The tools are installed under their gnux names only (rmx, never rm). The Node and npm guide has the rest: globs on Windows, the JavaScript API, CI.

A particular version

gnux --version reports what is installed. To install one version rather than the newest:

With Command
A release archive or package set v= above to the tag: every release stays available
go install go install github.com/braswelljr/gnux@v1.2.0
winget winget install braswelljr.gnux --version 1.2.0
Scoop scoop install gnux/gnux@1.2.0
Snap sudo snap install gnux --channel=edge for the newest prerelease
setup-gnux version: v1.2.0

Homebrew and the AUR carry the newest version only.

In GitHub Actions

The repository is also a GitHub Action, setup-gnux. It installs a release on a Linux, macOS or Windows runner, checks it against the release's checksums and puts gnux and every tool name on PATH:

- uses: braswelljr/gnux@v0
  with:
    version: latest       # or a tag, such as v1.2.0
    gnu-names: false      # true also links rm, cp, ls, ... ahead of the runner's own
- run: rmx -rf build && mkdirx -p build && cpx -r assets build/
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
Shell completion

gnux completion SHELL prints a completion script for bash, zsh, fish or powershell; the release archives carry them pre-generated in completions/.

source <(gnux completion bash)                    # bash, this session
gnux completion zsh > "${fpath[1]}/_gnux"         # zsh, permanently
gnux completion fish > ~/.config/fish/completions/gnux.fish
gnux completion powershell | Out-String | Invoke-Expression
Docker

Every release is on GHCR: ghcr.io/braswelljr/gnux (Alpine, every tool on the PATH) and the same tags with -scratch appended (gnux alone, FROM scratch, a base image the size of one binary).

docker run --rm -v "$(pwd):/work" ghcr.io/braswelljr/gnux:v1 lsx -la
docker run --rm -v "$(pwd):/work" ghcr.io/braswelljr/gnux:v1-scratch shell -c 'wcx -l *.go'

# or build it yourself:
docker build -t gnux .                     # Alpine
docker build -t gnux:scratch --target scratch .
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"
# release.gnux - run with: gnux shell -eu release.gnux v1.4.0
VERSION=${1:-dev}
for os in linux darwin windows; do
  case $os in
    windows) EXT=.exe ;;
    *)       EXT= ;;
  esac
  if [ -f bin/$os/app$EXT ]; then
    mkdir -p dist/$os && cp bin/$os/app$EXT dist/$os/
    echo "$VERSION $(sha256sum dist/$os/app$EXT)" >> dist/SUMS
  fi
done

It understands a deliberately small subset of POSIX sh: pipelines, && / || / ; / !, redirection (<, >, >>), NAME=value variables with $NAME, ${NAME}, ${NAME:-default} and $?, script arguments ($1, $#, "$@"), command substitution $(...), if, for, while and case, single and double quotes, globbing, ~ and # comments, with the builtins cd, exit, help, set, shift, break, continue and [. -e stops at the first failure and -u refuses a variable that was never set. There are no functions or arithmetic, and external programs are reached through envx PROGRAM ….

Sandboxed, and for AI agents

--sandbox DIR confines a script with the operating system's own sandbox (Landlock on Linux, Seatbelt on macOS, an AppContainer on Windows, Capsicum on FreeBSD): it can read and write DIR and nothing else, whatever it does, and so can every program it starts.

gnux shell --sandbox . -e ./build.gnux

gnux mcp DIR serves the tools to an AI agent over the Model Context Protocol, inside the same sandbox, so an agent can search, edit and remove files in one project and cannot reach anything outside it:

claude mcp add gnux -- gnux mcp "$PWD"

The sandbox guide covers the details, the configuration for other clients, and what the sandbox does not do.

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 generation of every reference format. The generated reference is not committed: it is built whenever it is needed.

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; a short fuzzing run of the shell
Build cross-compiles gnux for Linux, macOS, FreeBSD and Windows and uploads the binaries
Lint golangci-lint
Docs tests the generator, generates documentation/ and web/content/docs/, and keeps the reference as a run artifact
Web builds the WebAssembly binary, then lints, type-checks, tests and builds the website
Action installs a release with the setup-gnux action (action.yml) on Linux, macOS and Windows runners and uses the tools
Release on a v* tag: re-runs the checks, then GoReleaser (.goreleaser.yaml) builds an archive per platform, publishes them with .deb, .rpm and .apk packages, checksums, a provenance attestation and the tag's CHANGELOG.md section as notes, and publishes to Homebrew, Scoop, winget, the Snap Store and the AUR (how)

Documentation

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

The full reference is on the website at gnux.vercel.app/docs, and prints in the terminal with gnux help TOOL. make docs also generates it into documentation/ in markdown, man, YAML and reST, grouped by format so each directory is self-contained (documentation/markdown/ holds all markdown, etc.). These files are not committed; the release archives carry the man pages:

  • 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 the reference index. The website's pages (web/content/docs/) are generated from the same source. Generate 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         # generate documentation/ and web/content/docs/ (not committed)
make ci           # vet + lint + test + docs generation
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. The full list of planned tools, distribution channels and integrations, ticked off as they land, is docs/requirements/checklist.md.

  • Tools: none; every GNU coreutils tool but those below is implemented.
  • Out of scope by design: chroot, chcon and runcon, which change system-wide state that gnux leaves to the system's own tools

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.
archx
Package archx wires the archx command (GNU arch) to its engine.
Package archx wires the archx command (GNU arch) to its engine.
b2sumx
Package b2sumx wires the b2sumx command (GNU b2sum) to its engine.
Package b2sumx wires the b2sumx command (GNU b2sum) to its engine.
base32x
Package base32x wires the base32x command (GNU base32) to its engine.
Package base32x wires the base32x command (GNU base32) to its engine.
base64x
Package base64x wires the base64x command (GNU base64) to its engine.
Package base64x wires the base64x command (GNU base64) to its engine.
basenamex
Package basenamex wires the basenamex command (GNU basename) to its engine.
Package basenamex wires the basenamex command (GNU basename) to its engine.
basencx
Package basencx wires the basencx command (GNU basenc) to its engine, core/basenc.
Package basencx wires the basencx command (GNU basenc) to its engine, core/basenc.
catx
Package catx wires the catx command (GNU cat) to its engine.
Package catx wires the catx command (GNU cat) to its engine.
chgrpx
Package chgrpx wires the chgrpx command (GNU chgrp) to its engine.
Package chgrpx wires the chgrpx command (GNU chgrp) to its engine.
chmodx
Package chmodx wires the chmodx command (GNU chmod) to its engine.
Package chmodx wires the chmodx command (GNU chmod) to its engine.
chownx
Package chownx wires the chownx command (GNU chown) to its engine.
Package chownx wires the chownx command (GNU chown) to its engine.
cksumx
Package cksumx wires the cksumx command (GNU cksum) to its engine.
Package cksumx wires the cksumx command (GNU cksum) to its engine.
commx
Package commx wires the commx command (GNU comm) to its engine.
Package commx wires the commx command (GNU comm) 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.
csplitx
Package csplitx wires the csplitx command (GNU csplit) to its engine.
Package csplitx wires the csplitx command (GNU csplit) to its engine.
cutx
Package cutx wires the cutx command (GNU cut) to its engine.
Package cutx wires the cutx command (GNU cut) to its engine.
datex
Package datex wires the datex command (GNU date) to its engine.
Package datex wires the datex command (GNU date) to its engine.
ddx
Package ddx wires the ddx command (GNU dd) to its engine.
Package ddx wires the ddx command (GNU dd) to its engine.
dfx
Package dfx wires the dfx command (GNU df) to its engine.
Package dfx wires the dfx command (GNU df) to its engine.
dircolorsx
Package dircolorsx wires the dircolorsx command (GNU dircolors) to its engine.
Package dircolorsx wires the dircolorsx command (GNU dircolors) to its engine.
dirnamex
Package dirnamex wires the dirnamex command (GNU dirname) to its engine.
Package dirnamex wires the dirnamex command (GNU dirname) to its engine.
dirx
Package dirx wires the dirx command (GNU dir) to the lsx engine.
Package dirx wires the dirx command (GNU dir) to the lsx 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).
dux
Package dux wires the dux command (GNU du) to its engine.
Package dux wires the dux command (GNU du) to its engine.
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.
expandx
Package expandx wires the expandx command (GNU expand) to its engine.
Package expandx wires the expandx command (GNU expand) to its engine.
exprx
Package exprx wires the exprx command (GNU expr) to its engine.
Package exprx wires the exprx command (GNU expr) to its engine.
factorx
Package factorx wires the factorx command (GNU factor) to its engine.
Package factorx wires the factorx command (GNU factor) to its engine.
falsex
Package falsex implements the falsex command (GNU false).
Package falsex implements the falsex command (GNU false).
findx
Package findx wires the findx command (GNU find) to its engine.
Package findx wires the findx command (GNU find) to its engine.
fmtx
Package fmtx wires the fmtx command (GNU fmt) to its engine.
Package fmtx wires the fmtx command (GNU fmt) to its engine.
foldx
Package foldx wires the foldx command (GNU fold) to its engine.
Package foldx wires the foldx command (GNU fold) to its engine.
grepx
Package grepx wires the grepx command (GNU grep) to its engine.
Package grepx wires the grepx command (GNU grep) to its engine.
groupsx
Package groupsx wires the groupsx command (GNU groups) to its engine.
Package groupsx wires the groupsx command (GNU groups) to its engine.
headx
Package headx wires the headx command (GNU head) to its engine.
Package headx wires the headx command (GNU head) to its engine.
hostidx
Package hostidx wires the hostidx command (GNU hostid) to its engine.
Package hostidx wires the hostidx command (GNU hostid) to its engine.
hostnamex
Package hostnamex wires the hostnamex command (GNU coreutils hostname) to its engine.
Package hostnamex wires the hostnamex command (GNU coreutils hostname) to its engine.
idx
Package idx wires the idx command (GNU id) to its engine.
Package idx wires the idx command (GNU id) to its engine.
installx
Package installx wires the installx command (GNU install) to its engine.
Package installx wires the installx command (GNU install) to its engine.
joinx
Package joinx wires the joinx command (GNU join) to its engine.
Package joinx wires the joinx command (GNU join) to its engine.
killx
Package killx wires the killx command (GNU kill) to its engine.
Package killx wires the killx command (GNU kill) to its engine.
linkx
Package linkx wires the linkx command (GNU link) to its engine.
Package linkx wires the linkx command (GNU link) 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.
lognamex
Package lognamex wires the lognamex command (GNU logname) to its engine.
Package lognamex wires the lognamex command (GNU logname) to its 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.
md5sumx
Package md5sumx wires the md5sumx command (GNU md5sum) to its engine.
Package md5sumx wires the md5sumx command (GNU md5sum) to its engine.
mkdirx
Package mkdirx wires the mkdirx command (GNU mkdir) to its engine.
Package mkdirx wires the mkdirx command (GNU mkdir) to its engine.
mkfifox
Package mkfifox wires the mkfifox command (GNU mkfifo) to its engine.
Package mkfifox wires the mkfifox command (GNU mkfifo) to its engine.
mknodx
Package mknodx wires the mknodx command (GNU mknod) to its engine.
Package mknodx wires the mknodx command (GNU mknod) to its engine.
mktempx
Package mktempx wires the mktempx command (GNU mktemp) to its engine.
Package mktempx wires the mktempx command (GNU mktemp) 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.
nicex
Package nicex wires the nicex command (GNU nice) to its engine.
Package nicex wires the nicex command (GNU nice) to its engine.
nlx
Package nlx wires the nlx command (GNU nl) to its engine.
Package nlx wires the nlx command (GNU nl) to its engine.
nohupx
Package nohupx wires the nohupx command (GNU nohup) to its engine.
Package nohupx wires the nohupx command (GNU nohup) to its engine.
nprocx
Package nprocx wires the nprocx command (GNU nproc) to its engine.
Package nprocx wires the nprocx command (GNU nproc) to its engine.
numfmtx
Package numfmtx wires the numfmtx command (GNU numfmt) to its engine.
Package numfmtx wires the numfmtx command (GNU numfmt) to its engine.
odx
Package odx wires the odx command (GNU od) to its engine.
Package odx wires the odx command (GNU od) to its engine.
pastex
Package pastex wires the pastex command (GNU paste) to its engine.
Package pastex wires the pastex command (GNU paste) to its engine.
pathchkx
Package pathchkx wires the pathchkx command (GNU pathchk) to its engine.
Package pathchkx wires the pathchkx command (GNU pathchk) to its engine.
pinkyx
Package pinkyx wires the pinkyx command (GNU pinky) to its engine.
Package pinkyx wires the pinkyx command (GNU pinky) to its engine.
printenvx
Package printenvx wires the printenvx command (GNU printenv) to its engine.
Package printenvx wires the printenvx command (GNU printenv) to its engine.
printfx
Package printfx wires the printfx command (GNU printf) to its engine.
Package printfx wires the printfx command (GNU printf) to its engine.
prx
Package prx wires the prx command (GNU pr) to its engine.
Package prx wires the prx command (GNU pr) to its engine.
ptxx
Package ptxx wires the ptxx command (GNU ptx) to its engine.
Package ptxx wires the ptxx command (GNU ptx) to its engine.
pwdx
Package pwdx wires the pwdx command (GNU pwd) to its engine.
Package pwdx wires the pwdx command (GNU pwd) to its engine.
readlinkx
Package readlinkx wires the readlinkx command (GNU readlink) to its engine.
Package readlinkx wires the readlinkx command (GNU readlink) 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.
sedx
Package sedx wires the sedx command (GNU sed) to its engine.
Package sedx wires the sedx command (GNU sed) to its engine.
seqx
Package seqx wires the seqx command (GNU seq) to its engine.
Package seqx wires the seqx command (GNU seq) to its engine.
sha1sumx
Package sha1sumx wires the sha1sumx command (GNU sha1sum) to its engine.
Package sha1sumx wires the sha1sumx command (GNU sha1sum) to its engine.
sha224sumx
Package sha224sumx wires the sha224sumx command (GNU sha224sum) to its engine.
Package sha224sumx wires the sha224sumx command (GNU sha224sum) to its engine.
sha256sumx
Package sha256sumx wires the sha256sumx command (GNU sha256sum) to its engine.
Package sha256sumx wires the sha256sumx command (GNU sha256sum) to its engine.
sha384sumx
Package sha384sumx wires the sha384sumx command (GNU sha384sum) to its engine.
Package sha384sumx wires the sha384sumx command (GNU sha384sum) to its engine.
sha512sumx
Package sha512sumx wires the sha512sumx command (GNU sha512sum) to its engine.
Package sha512sumx wires the sha512sumx command (GNU sha512sum) to its engine.
shredx
Package shredx wires the shredx command (GNU shred) to its engine.
Package shredx wires the shredx command (GNU shred) to its engine.
shufx
Package shufx wires the shufx command (GNU shuf) to its engine.
Package shufx wires the shufx command (GNU shuf) to its engine.
sleepx
Package sleepx wires the sleepx command (GNU sleep) to its engine.
Package sleepx wires the sleepx command (GNU sleep) to its engine.
sortx
Package sortx wires the sortx command (GNU sort) to its engine.
Package sortx wires the sortx command (GNU sort) to its engine.
splitx
Package splitx wires the splitx command (GNU split) to its engine.
Package splitx wires the splitx command (GNU split) to its engine.
statx
Package statx wires the statx command (GNU stat) to its engine.
Package statx wires the statx command (GNU stat) to its engine.
stdbufx
Package stdbufx wires the stdbufx command (GNU stdbuf) to its engine.
Package stdbufx wires the stdbufx command (GNU stdbuf) to its engine.
sttyx
Package sttyx wires the sttyx command (GNU stty) to its engine.
Package sttyx wires the sttyx command (GNU stty) to its engine.
sumx
Package sumx wires the sumx command (GNU sum) to its engine.
Package sumx wires the sumx command (GNU sum) to its engine.
syncx
Package syncx wires the syncx command (GNU sync) to its engine.
Package syncx wires the syncx command (GNU sync) to its engine.
tacx
Package tacx wires the tacx command (GNU tac) to its engine.
Package tacx wires the tacx command (GNU tac) 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.
teex
Package teex wires the teex command (GNU tee) to its engine.
Package teex wires the teex command (GNU tee) to its engine.
testx
Package testx wires the testx command (GNU test) to its engine.
Package testx wires the testx command (GNU test) to its engine.
timeoutx
Package timeoutx wires the timeoutx command (GNU timeout) to its engine.
Package timeoutx wires the timeoutx command (GNU timeout) 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).
truncatex
Package truncatex wires the truncatex command (GNU truncate) to its engine.
Package truncatex wires the truncatex command (GNU truncate) to its engine.
trx
Package trx wires the trx command (GNU tr) to its engine.
Package trx wires the trx command (GNU tr) to its engine.
tsortx
Package tsortx wires the tsortx command (GNU tsort) to its engine.
Package tsortx wires the tsortx command (GNU tsort) to its engine.
ttyx
Package ttyx wires the ttyx command (GNU tty) to its engine.
Package ttyx wires the ttyx command (GNU tty) to its engine.
unamex
Package unamex wires the unamex command (GNU uname) to its engine.
Package unamex wires the unamex command (GNU uname) to its engine.
unexpandx
Package unexpandx wires the unexpandx command (GNU unexpand) to its engine.
Package unexpandx wires the unexpandx command (GNU unexpand) to its engine.
uniqx
Package uniqx wires the uniqx command (GNU uniq) to its engine.
Package uniqx wires the uniqx command (GNU uniq) to its engine.
unlinkx
Package unlinkx wires the unlinkx command (GNU unlink) to its engine.
Package unlinkx wires the unlinkx command (GNU unlink) to its engine.
uptimex
Package uptimex wires the uptimex command (GNU uptime) to its engine.
Package uptimex wires the uptimex command (GNU uptime) to its engine.
usersx
Package usersx wires the usersx command (GNU users) to its engine.
Package usersx wires the usersx command (GNU users) to its engine.
vdirx
Package vdirx wires the vdirx command (GNU vdir) to the lsx engine.
Package vdirx wires the vdirx command (GNU vdir) to the lsx engine.
wcx
Package wcx wires the wcx command (GNU wc) to its engine.
Package wcx wires the wcx command (GNU wc) to its engine.
whoamix
Package whoamix wires the whoamix command (GNU whoami) to its engine.
Package whoamix wires the whoamix command (GNU whoami) to its engine.
whox
Package whox wires the whox command (GNU who) to its engine.
Package whox wires the whox command (GNU who) to its engine.
xargsx
Package xargsx wires the xargsx command (GNU xargs) to its engine.
Package xargsx wires the xargsx command (GNU xargs) 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.
arch
Package arch implements the engine behind archx, a GNU-compatible implementation of the GNU arch command: print the machine hardware name, as uname -m does.
Package arch implements the engine behind archx, a GNU-compatible implementation of the GNU arch command: print the machine hardware name, as uname -m does.
b2sum
Package b2sum implements the engine behind b2sumx, a GNU-compatible implementation of the GNU/UNIX b2sum command: print or check BLAKE2b (512-bit by default) message digests.
Package b2sum implements the engine behind b2sumx, a GNU-compatible implementation of the GNU/UNIX b2sum command: print or check BLAKE2b (512-bit by default) message digests.
base32
Package base32 implements the engine behind base32x, a GNU-compatible implementation of the GNU/UNIX base32 command: base32 encode or decode a file or standard input (RFC 4648).
Package base32 implements the engine behind base32x, a GNU-compatible implementation of the GNU/UNIX base32 command: base32 encode or decode a file or standard input (RFC 4648).
base64
Package base64 implements the engine behind base64x, a GNU-compatible implementation of the GNU/UNIX base64 command: base64 encode or decode a file or standard input (RFC 4648).
Package base64 implements the engine behind base64x, a GNU-compatible implementation of the GNU/UNIX base64 command: base64 encode or decode a file or standard input (RFC 4648).
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.
basenc
Package basenc implements the engine behind basencx, a GNU-compatible implementation of the GNU/UNIX basenc command: encode a file or standard input in one of several encodings (RFC 4648 base64, base64url, base32, base32hex and base16, a bit string either way round, and Z85), or decode it.
Package basenc implements the engine behind basencx, a GNU-compatible implementation of the GNU/UNIX basenc command: encode a file or standard input in one of several encodings (RFC 4648 base64, base64url, base32, base32hex and base16, a bit string either way round, and Z85), or decode it.
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.
chgrp
Package chgrp implements the engine behind chgrpx, a GNU-compatible implementation of the GNU/UNIX chgrp command: change the group of files.
Package chgrp implements the engine behind chgrpx, a GNU-compatible implementation of the GNU/UNIX chgrp command: change the group of files.
chmod
Package chmod implements the engine behind chmodx, a GNU-compatible implementation of the GNU/UNIX chmod command: change the permission bits of files.
Package chmod implements the engine behind chmodx, a GNU-compatible implementation of the GNU/UNIX chmod command: change the permission bits of files.
chown
Package chown implements the engine behind chownx, a GNU-compatible implementation of the GNU/UNIX chown command: change the owner and group of files.
Package chown implements the engine behind chownx, a GNU-compatible implementation of the GNU/UNIX chown command: change the owner and group of files.
cksum
Package cksum implements the engine behind cksumx, a GNU-compatible implementation of the GNU/UNIX cksum command: print or check a CRC, a legacy checksum or a message digest for each file.
Package cksum implements the engine behind cksumx, a GNU-compatible implementation of the GNU/UNIX cksum command: print or check a CRC, a legacy checksum or a message digest for each file.
comm
Package comm implements the engine behind commx, a GNU-compatible implementation of the GNU/UNIX comm command: compare two sorted files line by line.
Package comm implements the engine behind commx, a GNU-compatible implementation of the GNU/UNIX comm command: compare two sorted files line by line.
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.
csplit
Package csplit implements the engine behind csplitx, a GNU-compatible implementation of the GNU/UNIX csplit command: split a file into sections determined by context lines.
Package csplit implements the engine behind csplitx, a GNU-compatible implementation of the GNU/UNIX csplit command: split a file into sections determined by context lines.
cut
Package cut implements the engine behind cutx, a GNU-compatible implementation of the GNU/UNIX cut command: remove sections from each line of files.
Package cut implements the engine behind cutx, a GNU-compatible implementation of the GNU/UNIX cut command: remove sections from each line of files.
date
Package date implements the engine behind datex, a GNU-compatible implementation of the GNU/UNIX date command: print a date and time in a given format, now or as described by -d, -f or -r.
Package date implements the engine behind datex, a GNU-compatible implementation of the GNU/UNIX date command: print a date and time in a given format, now or as described by -d, -f or -r.
dd
Package dd implements the engine behind ddx, a GNU-compatible implementation of the GNU/UNIX dd command: copy a file block by block, converting it on the way, and report what was copied.
Package dd implements the engine behind ddx, a GNU-compatible implementation of the GNU/UNIX dd command: copy a file block by block, converting it on the way, and report what was copied.
df
Package df implements the engine behind dfx, a GNU-compatible implementation of the GNU/UNIX df command: report file system space usage.
Package df implements the engine behind dfx, a GNU-compatible implementation of the GNU/UNIX df command: report file system space usage.
dircolors
Package dircolors implements the engine behind dircolorsx, a GNU-compatible implementation of the GNU/UNIX dircolors command: print shell commands that set LS_COLORS, the colors lsx --color uses.
Package dircolors implements the engine behind dircolorsx, a GNU-compatible implementation of the GNU/UNIX dircolors command: print shell commands that set LS_COLORS, the colors lsx --color uses.
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.
du
Package du implements the engine behind dux, a GNU-compatible implementation of the GNU/UNIX du command: estimate file space usage.
Package du implements the engine behind dux, a GNU-compatible implementation of the GNU/UNIX du command: estimate file space usage.
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.
expand
Package expand implements the engine behind expandx, a GNU-compatible implementation of the GNU/UNIX expand command: convert tabs to spaces.
Package expand implements the engine behind expandx, a GNU-compatible implementation of the GNU/UNIX expand command: convert tabs to spaces.
expr
Package expr implements the engine behind exprx, a GNU-compatible implementation of the GNU/UNIX expr command: evaluate an expression given as separate arguments and print its value.
Package expr implements the engine behind exprx, a GNU-compatible implementation of the GNU/UNIX expr command: evaluate an expression given as separate arguments and print its value.
factor
Package factor implements the engine behind factorx, a GNU-compatible implementation of the GNU factor command: print the prime factors of each number.
Package factor implements the engine behind factorx, a GNU-compatible implementation of the GNU factor command: print the prime factors of each number.
find
Package find implements the engine behind findx, a GNU-compatible implementation of the find command: walk directory trees and evaluate an expression of tests and actions against every file met.
Package find implements the engine behind findx, a GNU-compatible implementation of the find command: walk directory trees and evaluate an expression of tests and actions against every file met.
fmt
Package fmt implements the engine behind fmtx, a GNU-compatible implementation of the GNU/UNIX fmt command: a simple optimal text formatter that refills paragraphs to a goal width.
Package fmt implements the engine behind fmtx, a GNU-compatible implementation of the GNU/UNIX fmt command: a simple optimal text formatter that refills paragraphs to a goal width.
fold
Package fold implements the engine behind foldx, a GNU-compatible implementation of the GNU/UNIX fold command: wrap each input line to fit in a specified width.
Package fold implements the engine behind foldx, a GNU-compatible implementation of the GNU/UNIX fold command: wrap each input line to fit in a specified width.
fsys
Package fsys is how the engines reach the file system.
Package fsys is how the engines reach the file system.
grep
Package grep implements the engine behind grepx, a GNU-compatible implementation of the grep command: print the lines that match patterns.
Package grep implements the engine behind grepx, a GNU-compatible implementation of the grep command: print the lines that match patterns.
groups
Package groups implements the engine behind groupsx, a GNU-compatible implementation of the GNU groups command: print the groups a user is in.
Package groups implements the engine behind groupsx, a GNU-compatible implementation of the GNU groups command: print the groups a user is in.
hashsum
Package hashsum is the engine shared by the GNU message digest tools: md5sumx, sha1sumx, sha224sumx, sha256sumx, sha384sumx, sha512sumx, b2sumx, and the digest algorithms of cksumx.
Package hashsum is the engine shared by the GNU message digest tools: md5sumx, sha1sumx, sha224sumx, sha256sumx, sha384sumx, sha512sumx, b2sumx, and the digest algorithms of cksumx.
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.
hostid
Package hostid implements the engine behind hostidx, a GNU-compatible implementation of the GNU/UNIX hostid command: print the numeric identifier of the current host.
Package hostid implements the engine behind hostidx, a GNU-compatible implementation of the GNU/UNIX hostid command: print the numeric identifier of the current host.
hostname
Package hostname implements the engine behind hostnamex, a GNU-compatible implementation of the GNU coreutils hostname command: print the name of the current host system.
Package hostname implements the engine behind hostnamex, a GNU-compatible implementation of the GNU coreutils hostname command: print the name of the current host system.
id
Package id implements the engine behind idx, a GNU-compatible implementation of the GNU/UNIX id command: print the user and group IDs of the current process or of the named users.
Package id implements the engine behind idx, a GNU-compatible implementation of the GNU/UNIX id command: print the user and group IDs of the current process or of the named users.
install
Package install implements the engine behind installx, a GNU-compatible implementation of the GNU/UNIX install command: copy files into place and set their permission mode, owner and group, or create directories.
Package install implements the engine behind installx, a GNU-compatible implementation of the GNU/UNIX install command: copy files into place and set their permission mode, owner and group, or create directories.
internal/bre
Package bre translates POSIX basic regular expressions (BRE), the syntax GNU expr, nl and csplit take, into Go's RE2 syntax.
Package bre translates POSIX basic regular expressions (BRE), the syntax GNU expr, nl and csplit take, into Go's RE2 syntax.
internal/fnmatch
Package fnmatch matches names against shell patterns as fnmatch(3) does with no flags: the matching GNU find's -name and dircolors' TERM lines use.
Package fnmatch matches names against shell patterns as fnmatch(3) does with no flags: the matching GNU find's -name and dircolors' TERM lines use.
internal/fsstat
Package fsstat reports file system statistics (statfs) and the mounted file systems, for statx -f and dfx.
Package fsstat reports file system statistics (statfs) and the mounted file systems, for statx -f and dfx.
internal/human
Package human formats sizes the way GNU du, df and ls do (gnulib's human_readable) and parses their --block-size argument (gnulib's humblock), so "1.5K", "10M" and "-BM" mean exactly what they mean in GNU.
Package human formats sizes the way GNU du, df and ls do (gnulib's human_readable) and parses their --block-size argument (gnulib's humblock), so "1.5K", "10M" and "-BM" mean exactly what they mean in GNU.
internal/mode
Package mode reads the MODE argument of mkdir -m, mkfifo -m and mknod -m: an octal number or chmod's symbolic clauses, applied to the mode a new file starts with.
Package mode reads the MODE argument of mkdir -m, mkfifo -m and mknod -m: an octal number or chmod's symbolic clauses, applied to the mode a new file starts with.
internal/ownership
Package ownership is the engine shared by chownx and chgrpx: changing the owner and group of files, with GNU chown's reporting, traversal and symbolic link rules.
Package ownership is the engine shared by chownx and chgrpx: changing the owner and group of files, with GNU chown's reporting, traversal and symbolic link rules.
internal/quote
Package quote renders file names in gnulib's shell-escape quoting style, the style GNU stat and du use: a name is left alone when a shell would read it back unchanged, single-quoted otherwise, with control characters written as $'\n' outside the quotes.
Package quote renders file names in gnulib's shell-escape quoting style, the style GNU stat and du use: a name is left alone when a shell would read it back unchanged, single-quoted otherwise, with control characters written as $'\n' outside the quotes.
internal/quotearg
Package quotearg quotes strings as gnulib's quotearg module does: the quoting styles behind GNU ls --quoting-style, and the quotes GNU tools put around names in their messages.
Package quotearg quotes strings as gnulib's quotearg module does: the quoting styles behind GNU ls --quoting-style, and the quotes GNU tools put around names in their messages.
internal/run
Package run starts the command a tool was asked to run for the user: what xargs builds from its input, and what find runs for -exec.
Package run starts the command a tool was asked to run for the user: what xargs builds from its input, and what find runs for -exec.
internal/special
Package special creates special files: named pipes for mkfifo, and pipes and device files for mknod.
Package special creates special files: named pipes for mkfifo, and pipes and device files for mknod.
internal/sysstat
Package sysstat exposes the parts of a file's metadata that os.FileInfo does not: inode, link count, owner, blocks, device numbers and the access, change and birth times.
Package sysstat exposes the parts of a file's metadata that os.FileInfo does not: inode, link count, owner, blocks, device numbers and the access, change and birth times.
internal/utmp
Package utmp reads the record of who is logged in (the utmp or utmpx file) and reports the boot time and load average, for whox and uptimex.
Package utmp reads the record of who is logged in (the utmp or utmpx file) and reports the boot time and load average, for whox and uptimex.
join
Package join implements the engine behind joinx, a GNU-compatible implementation of the GNU/UNIX join command: join the lines of two files on a common field.
Package join implements the engine behind joinx, a GNU-compatible implementation of the GNU/UNIX join command: join the lines of two files on a common field.
kill
Package kill implements the engine behind killx, a GNU-compatible implementation of the GNU/UNIX kill command: send a signal to processes, or list the signal names and numbers.
Package kill implements the engine behind killx, a GNU-compatible implementation of the GNU/UNIX kill command: send a signal to processes, or list the signal names and numbers.
link
Package link implements the engine behind linkx, a GNU-compatible implementation of the GNU link command: make a hard link with the link(2) system call, and nothing more.
Package link implements the engine behind linkx, a GNU-compatible implementation of the GNU link command: make a hard link with the link(2) system call, and nothing more.
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.
logname
Package logname implements the engine behind lognamex, a GNU-compatible implementation of the GNU logname command: print the name the user logged in as.
Package logname implements the engine behind lognamex, a GNU-compatible implementation of the GNU logname command: print the name the user logged in as.
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.
md5sum
Package md5sum implements the engine behind md5sumx, a GNU-compatible implementation of the GNU/UNIX md5sum command: print or check MD5 (128-bit) message digests.
Package md5sum implements the engine behind md5sumx, a GNU-compatible implementation of the GNU/UNIX md5sum command: print or check MD5 (128-bit) message digests.
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.
mkfifo
Package mkfifo implements the engine behind mkfifox, a GNU-compatible implementation of the GNU/UNIX mkfifo command: create named pipes.
Package mkfifo implements the engine behind mkfifox, a GNU-compatible implementation of the GNU/UNIX mkfifo command: create named pipes.
mknod
Package mknod implements the engine behind mknodx, a GNU-compatible implementation of the GNU/UNIX mknod command: create a block or character device file, or a named pipe.
Package mknod implements the engine behind mknodx, a GNU-compatible implementation of the GNU/UNIX mknod command: create a block or character device file, or a named pipe.
mktemp
Package mktemp implements the engine behind mktempx, a GNU-compatible implementation of the GNU/UNIX mktemp command: create a uniquely named temporary file or directory and print its name.
Package mktemp implements the engine behind mktempx, a GNU-compatible implementation of the GNU/UNIX mktemp command: create a uniquely named temporary file or directory and print its name.
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.
nice
Package nice implements the engine behind nicex, a GNU-compatible implementation of the GNU/UNIX nice command: run a command with an adjusted niceness (scheduling priority), or print the current niceness.
Package nice implements the engine behind nicex, a GNU-compatible implementation of the GNU/UNIX nice command: run a command with an adjusted niceness (scheduling priority), or print the current niceness.
nl
Package nl implements the engine behind nlx, a GNU-compatible implementation of the GNU/UNIX nl command: number the lines of files.
Package nl implements the engine behind nlx, a GNU-compatible implementation of the GNU/UNIX nl command: number the lines of files.
nohup
Package nohup implements the engine behind nohupx, a GNU-compatible implementation of the GNU/UNIX nohup command: run a command immune to hangups, with output to a file when it would otherwise go to a terminal.
Package nohup implements the engine behind nohupx, a GNU-compatible implementation of the GNU/UNIX nohup command: run a command immune to hangups, with output to a file when it would otherwise go to a terminal.
nproc
Package nproc implements the engine behind nprocx, a GNU-compatible implementation of the GNU nproc command: print the number of processing units available.
Package nproc implements the engine behind nprocx, a GNU-compatible implementation of the GNU nproc command: print the number of processing units available.
numfmt
Package numfmt implements the engine behind numfmtx, a GNU-compatible implementation of the GNU/UNIX numfmt command: convert numbers to and from human-readable strings such as 1.5K, 2.0Mi or 977k.
Package numfmt implements the engine behind numfmtx, a GNU-compatible implementation of the GNU/UNIX numfmt command: convert numbers to and from human-readable strings such as 1.5K, 2.0Mi or 977k.
od
Package od implements the engine behind odx, a GNU-compatible implementation of the GNU/UNIX od command: dump files in octal and other formats.
Package od implements the engine behind odx, a GNU-compatible implementation of the GNU/UNIX od command: dump files in octal and other formats.
paste
Package paste implements the engine behind pastex, a GNU-compatible implementation of the GNU/UNIX paste command: merge lines of files.
Package paste implements the engine behind pastex, a GNU-compatible implementation of the GNU/UNIX paste command: merge lines of files.
pathchk
Package pathchk implements the engine behind pathchkx, a GNU-compatible implementation of the GNU/UNIX pathchk command: check whether file names are valid on this system, or portable to any POSIX system.
Package pathchk implements the engine behind pathchkx, a GNU-compatible implementation of the GNU/UNIX pathchk command: check whether file names are valid on this system, or portable to any POSIX system.
pinky
Package pinky implements the engine behind pinkyx, a GNU-compatible implementation of the GNU/UNIX pinky command: a lightweight finger, which shows who is logged in, or what the system knows about given users.
Package pinky implements the engine behind pinkyx, a GNU-compatible implementation of the GNU/UNIX pinky command: a lightweight finger, which shows who is logged in, or what the system knows about given users.
pr
Package pr implements the engine behind prx, a GNU-compatible implementation of the GNU/UNIX pr command: paginate or columnate files for printing.
Package pr implements the engine behind prx, a GNU-compatible implementation of the GNU/UNIX pr command: paginate or columnate files for printing.
printenv
Package printenv implements the engine behind printenvx, a GNU-compatible implementation of the GNU printenv command: print all or part of the environment.
Package printenv implements the engine behind printenvx, a GNU-compatible implementation of the GNU printenv command: print all or part of the environment.
printf
Package printf implements the engine behind printfx, a GNU-compatible implementation of the GNU/UNIX printf command: format and print the arguments under the control of a format string.
Package printf implements the engine behind printfx, a GNU-compatible implementation of the GNU/UNIX printf command: format and print the arguments under the control of a format string.
ptx
Package ptx implements the engine behind ptxx, a GNU-compatible implementation of the GNU/UNIX ptx command: produce a permuted index of the words of a text, each keyword shown in its context.
Package ptx implements the engine behind ptxx, a GNU-compatible implementation of the GNU/UNIX ptx command: produce a permuted index of the words of a text, each keyword shown in its context.
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.
readlink
Package readlink implements the engine behind readlinkx, a GNU-compatible implementation of the GNU readlink command: print the value of a symbolic link, or the canonical name of a file.
Package readlink implements the engine behind readlinkx, a GNU-compatible implementation of the GNU readlink command: print the value of a symbolic link, or the canonical name of a file.
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.
sed
Package sed implements the engine behind sedx, a GNU-compatible implementation of the GNU/UNIX sed command: a stream editor that filters and transforms text one line at a time under the control of a script.
Package sed implements the engine behind sedx, a GNU-compatible implementation of the GNU/UNIX sed command: a stream editor that filters and transforms text one line at a time under the control of a script.
seq
Package seq implements the engine behind seqx, a GNU-compatible implementation of the GNU/UNIX seq command: print a sequence of numbers.
Package seq implements the engine behind seqx, a GNU-compatible implementation of the GNU/UNIX seq command: print a sequence of numbers.
sha1sum
Package sha1sum implements the engine behind sha1sumx, a GNU-compatible implementation of the GNU/UNIX sha1sum command: print or check SHA-1 (160-bit) message digests.
Package sha1sum implements the engine behind sha1sumx, a GNU-compatible implementation of the GNU/UNIX sha1sum command: print or check SHA-1 (160-bit) message digests.
sha224sum
Package sha224sum implements the engine behind sha224sumx, a GNU-compatible implementation of the GNU/UNIX sha224sum command: print or check SHA-224 (224-bit) message digests.
Package sha224sum implements the engine behind sha224sumx, a GNU-compatible implementation of the GNU/UNIX sha224sum command: print or check SHA-224 (224-bit) message digests.
sha256sum
Package sha256sum implements the engine behind sha256sumx, a GNU-compatible implementation of the GNU/UNIX sha256sum command: print or check SHA-256 (256-bit) message digests.
Package sha256sum implements the engine behind sha256sumx, a GNU-compatible implementation of the GNU/UNIX sha256sum command: print or check SHA-256 (256-bit) message digests.
sha384sum
Package sha384sum implements the engine behind sha384sumx, a GNU-compatible implementation of the GNU/UNIX sha384sum command: print or check SHA-384 (384-bit) message digests.
Package sha384sum implements the engine behind sha384sumx, a GNU-compatible implementation of the GNU/UNIX sha384sum command: print or check SHA-384 (384-bit) message digests.
sha512sum
Package sha512sum implements the engine behind sha512sumx, a GNU-compatible implementation of the GNU/UNIX sha512sum command: print or check SHA-512 (512-bit) message digests.
Package sha512sum implements the engine behind sha512sumx, a GNU-compatible implementation of the GNU/UNIX sha512sum command: print or check SHA-512 (512-bit) message digests.
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.
shred
Package shred implements the engine behind shredx, a GNU-compatible implementation of the GNU/UNIX shred command: overwrite a file to hide its contents, and optionally remove it.
Package shred implements the engine behind shredx, a GNU-compatible implementation of the GNU/UNIX shred command: overwrite a file to hide its contents, and optionally remove it.
shuf
Package shuf implements the engine behind shufx, a GNU-compatible implementation of the GNU/UNIX shuf command: write a random permutation of the input lines, of the operands (-e) or of a range of numbers (-i).
Package shuf implements the engine behind shufx, a GNU-compatible implementation of the GNU/UNIX shuf command: write a random permutation of the input lines, of the operands (-e) or of a range of numbers (-i).
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.
sort
Package sort implements the engine behind sortx, a GNU-compatible implementation of the GNU/UNIX sort command: sort, merge or check the lines of text files.
Package sort implements the engine behind sortx, a GNU-compatible implementation of the GNU/UNIX sort command: sort, merge or check the lines of text files.
split
Package split implements the engine behind splitx, a GNU-compatible implementation of the GNU/UNIX split command: split a file into pieces.
Package split implements the engine behind splitx, a GNU-compatible implementation of the GNU/UNIX split command: split a file into pieces.
stat
Package stat implements the engine behind statx, a GNU-compatible implementation of the GNU/UNIX stat command: display file or file system status.
Package stat implements the engine behind statx, a GNU-compatible implementation of the GNU/UNIX stat command: display file or file system status.
stdbuf
Package stdbuf implements the engine behind stdbufx, a GNU-compatible implementation of the GNU/UNIX stdbuf command: run a command with different buffering of its standard streams.
Package stdbuf implements the engine behind stdbufx, a GNU-compatible implementation of the GNU/UNIX stdbuf command: run a command with different buffering of its standard streams.
stty
Package stty implements the engine behind sttyx, a GNU-compatible implementation of the GNU/UNIX stty command: print or change the settings of a terminal.
Package stty implements the engine behind sttyx, a GNU-compatible implementation of the GNU/UNIX stty command: print or change the settings of a terminal.
sum
Package sum implements the engine behind sumx, a GNU-compatible implementation of the GNU sum command: print the 16-bit checksum and block count of each file.
Package sum implements the engine behind sumx, a GNU-compatible implementation of the GNU sum command: print the 16-bit checksum and block count of each file.
sync
Package sync implements the engine behind syncx, a GNU-compatible implementation of the GNU/UNIX sync command: flush cached writes to persistent storage, for the whole system or for the files named.
Package sync implements the engine behind syncx, a GNU-compatible implementation of the GNU/UNIX sync command: flush cached writes to persistent storage, for the whole system or for the files named.
tac
Package tac implements the engine behind tacx, a GNU-compatible implementation of the GNU/UNIX tac command: concatenate and print files in reverse, last record first.
Package tac implements the engine behind tacx, a GNU-compatible implementation of the GNU/UNIX tac command: concatenate and print files in reverse, last record first.
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.
tee
Package tee implements the engine behind teex, a GNU-compatible implementation of the GNU/UNIX tee command: copy standard input to standard output and to every FILE.
Package tee implements the engine behind teex, a GNU-compatible implementation of the GNU/UNIX tee command: copy standard input to standard output and to every FILE.
test
Package test implements the engine behind testx, a GNU-compatible implementation of the GNU/UNIX test command: evaluate a conditional expression and report the result as the exit status.
Package test implements the engine behind testx, a GNU-compatible implementation of the GNU/UNIX test command: evaluate a conditional expression and report the result as the exit status.
timeout
Package timeout implements the engine behind timeoutx, a GNU-compatible implementation of the GNU/UNIX timeout command: run a command, and signal it if it is still running after a time limit.
Package timeout implements the engine behind timeoutx, a GNU-compatible implementation of the GNU/UNIX timeout command: run a command, and signal it if it is still running after a time limit.
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.
tr
Package tr implements the engine behind trx, a GNU-compatible implementation of the GNU/UNIX tr command: translate, squeeze and delete bytes read from standard input, writing the result to standard output.
Package tr implements the engine behind trx, a GNU-compatible implementation of the GNU/UNIX tr command: translate, squeeze and delete bytes read from standard input, writing the result to standard output.
truncate
Package truncate implements the engine behind truncatex, a GNU-compatible implementation of the GNU/UNIX truncate command: shrink or extend the size of each file to a given size.
Package truncate implements the engine behind truncatex, a GNU-compatible implementation of the GNU/UNIX truncate command: shrink or extend the size of each file to a given size.
tsort
Package tsort implements the engine behind tsortx, a GNU-compatible implementation of the GNU tsort command: print a total ordering consistent with the partial ordering given as pairs of strings.
Package tsort implements the engine behind tsortx, a GNU-compatible implementation of the GNU tsort command: print a total ordering consistent with the partial ordering given as pairs of strings.
tty
Package tty implements the engine behind ttyx, a GNU-compatible implementation of the GNU/UNIX tty command: print the file name of the terminal connected to standard input.
Package tty implements the engine behind ttyx, a GNU-compatible implementation of the GNU/UNIX tty command: print the file name of the terminal connected to standard input.
uname
Package uname implements the engine behind unamex, a GNU-compatible implementation of the GNU uname command: print system information.
Package uname implements the engine behind unamex, a GNU-compatible implementation of the GNU uname command: print system information.
unexpand
Package unexpand implements the engine behind unexpandx, a GNU-compatible implementation of the GNU/UNIX unexpand command: convert spaces to tabs.
Package unexpand implements the engine behind unexpandx, a GNU-compatible implementation of the GNU/UNIX unexpand command: convert spaces to tabs.
uniq
Package uniq implements the engine behind uniqx, a GNU-compatible implementation of the GNU/UNIX uniq command: report or omit repeated lines.
Package uniq implements the engine behind uniqx, a GNU-compatible implementation of the GNU/UNIX uniq command: report or omit repeated lines.
unlink
Package unlink implements the engine behind unlinkx, a GNU-compatible implementation of the GNU unlink command: remove one file with the unlink(2) system call, and nothing more.
Package unlink implements the engine behind unlinkx, a GNU-compatible implementation of the GNU unlink command: remove one file with the unlink(2) system call, and nothing more.
uptime
Package uptime implements the engine behind uptimex, a GNU-compatible implementation of the GNU/UNIX uptime command: tell how long the system has been running.
Package uptime implements the engine behind uptimex, a GNU-compatible implementation of the GNU/UNIX uptime command: tell how long the system has been running.
users
Package users implements the engine behind usersx, a GNU-compatible implementation of the GNU users command: print the user names of the users logged in.
Package users implements the engine behind usersx, a GNU-compatible implementation of the GNU users command: print the user names of the users logged in.
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.
who
Package who implements the engine behind whox, a GNU-compatible implementation of the GNU/UNIX who command: show who is logged on.
Package who implements the engine behind whox, a GNU-compatible implementation of the GNU/UNIX who command: show who is logged on.
whoami
Package whoami implements the engine behind whoamix, a GNU-compatible implementation of the GNU whoami command: print the effective user name.
Package whoami implements the engine behind whoamix, a GNU-compatible implementation of the GNU whoami command: print the effective user name.
xargs
Package xargs implements the engine behind xargsx, a GNU-compatible implementation of the xargs command: build command lines from the items read on standard input and run them.
Package xargs implements the engine behind xargsx, a GNU-compatible implementation of the xargs command: build command lines from the items read on standard input and run them.
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
codec
Package codec is the command-line adapter shared by base64x and base32x: their flags, their documentation and the mapping onto basenc.Options.
Package codec is the command-line adapter shared by base64x and base32x: their flags, their documentation and the mapping onto basenc.Options.
common
Package common holds app-wide constants shared across packages.
Package common holds app-wide constants shared across packages.
digest
Package digest is the command-line adapter shared by the message digest tools (md5sumx, sha1sumx, sha224sumx, sha256sumx, sha384sumx, sha512sumx, b2sumx): their flags, their documentation and the mapping onto hashsum.Options.
Package digest is the command-line adapter shared by the message digest tools (md5sumx, sha1sumx, sha224sumx, sha256sumx, sha384sumx, sha512sumx, b2sumx): their flags, their documentation and the mapping onto hashsum.Options.
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.
mcp
Package mcp is a small Model Context Protocol server: JSON-RPC 2.0 over a stream, one message per line, as MCP's stdio transport has it.
Package mcp is a small Model Context Protocol server: JSON-RPC 2.0 over a stream, one message per line, as MCP's stdio transport has it.
obsolete
Package obsolete lets an adapter accept GNU's obsolete "-NUM" option form (fold -72, fmt -60, split -1000, expand -4) alongside the flag that replaced it: either the one given last wins (Number and String), or both add to one list in the order given (List).
Package obsolete lets an adapter accept GNU's obsolete "-NUM" option form (fold -72, fmt -60, split -1000, expand -4) alongside the flag that replaced it: either the one given last wins (Number and String), or both add to one list in the order given (List).
sandbox
Package sandbox confines the gnux process to the directories it is given, with the operating system's own sandbox: Landlock on Linux, Seatbelt (sandbox-exec) on macOS, an AppContainer on Windows and Capsicum on FreeBSD.
Package sandbox confines the gnux process to the directories it is given, with the operating system's own sandbox: Landlock on Linux, Seatbelt (sandbox-exec) on macOS, an AppContainer on Windows and Capsicum on FreeBSD.
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
benchcheck command
Command benchcheck compares two files of `go test -bench` output and fails when a benchmark got slower or started allocating more: the pass/fail check that `make bench/check` and the Bench workflow run.
Command benchcheck compares two files of `go test -bench` output and fails when a benchmark got slower or started allocating more: the pass/fail check that `make bench/check` and the Bench workflow run.
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.
docsnap command
Command docsnap makes the website's documentation of a release: the docs as that version shipped, laid out to sit beside the latest ones under /docs/vX.Y (the tag's major and minor version: a patch release replaces its minor version's docs).
Command docsnap makes the website's documentation of a release: the docs as that version shipped, laid out to sit beside the latest ones under /docs/vX.Y (the tag's major and minor version: a patch release replaces its minor version's docs).
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.
npm command
Command npm assembles the npm packages of a gnux release from its archives, for the release workflow to publish.
Command npm assembles the npm packages of a gnux release from its archives, for the release workflow to publish.
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