Changelog
Every notable change to gnux, release by release, newest first. The format follows Keep a Changelog and gnux uses Semantic Versioning. Changes land under Unreleased as they are made, and that section becomes the next version when it is tagged; the release workflow publishes the version's section as its GitHub release notes.
Unreleased
1.5.1 - 2026-11-03
gnux 1.5.1 is a patch release. On the website, the trees, frames, tables and bars of the
terminal view are drawn with straight, unbroken lines; on Windows, prx names a directory
operand as GNU does, and the test suite passes in full again.
Fixed
- The website draws the terminal view's lines straight and unbroken, in the playground and in
the docs. It loaded JetBrains Mono from Google in subsets that leave out the box-drawing and
block characters, so each browser drew trees, frames and bars in another font, of another
width and height, and the lines came out bent and broken; the site now serves the whole font
itself (SIL OFL 1.1, in
web/src/fonts). The playground's line height is 1.375, under the 1.52 at which those lines stop joining, so a tree or a frame has no gaps between rows. prxon Windows names a directory operand as GNU does (Is a directory), not with the system'sIncorrect function.- The Windows test suite passes in full: the
pathchkxandprintenvxtests no longer expect an unquoted drive path or a:list separator.
1.5.0 - 2026-11-03
gnux 1.5.0 makes the terminal view's theme something you choose once. gnux theme opens a
picker with a live preview of each theme on real-looking output, and Enter keeps the theme for
every tool; gnux theme set, show and reset do the same from a script. Twenty built-in
themes join the 32: Apple's system colors (ios) and Xcode's, Material, Tomorrow,
Selenized, Flexoki, gnux's own colorful and monochrome, and the dark Zenburn, SynthWave '84,
Horizon and Moonlight. The release also fixes syncx and pathchkx on Windows, where the test
suite passes again.
Added
gnux theme: on a terminal, a picker of the built-in themes in a frame fitted to the terminal: tabs grouping them (All, Adaptive, Dark, Light), a search line that filters as you type, the list with each theme's kind, the theme under the cursor drawn beside it on a long listing, Git's marks, a check's verdicts, usage bars and an environment line, and a footer of key hints; Enter saves, Esc leaves, and the alternate screen keeps your scrollback.gnux theme set NAME,showandresetdo it from scripts, choosingdefaultresets, andgnux theme listis whatgnux themesnow runs (FR-184, FR-187).- Help follows the theme:
--help,gnux helpand the gnux mark take their heading, command and dimmed colors from the theme in use (they keep their colors when none is chosen). - The saved theme: one built-in name in
~/.config/gnux/theme($XDG_CONFIG_HOME/gnux,%AppData%\gnuxon Windows, orGNUX_CONFIG_DIR), used by every tool when neither--themenorGNUX_THEMEnames a theme, and read only for colored output. Only a built-in name is accepted: a file holding anything else, larger than 64 bytes or not a regular file is reported and ignored. It is opened without blocking and checked through the open file, so a named pipe cannot hang a tool and nothing can be swapped in between; it is written whole (renamed into place, never through a link), readable by its owner only. The picker echoes only printable text and restores the terminal however it ends. - Twenty themes: the families
ios,xcode,material,tomorrow,selenized,flexoki,colorfulandmonochrome(each-darkand-light), and the darkzenburn,synthwave,horizonandmoonlight. Every color reads at a contrast of at least 3:1 on its theme's background. core.ThemeShowcase,core.ResolveThemeandcore.UnicodeTerminalfor library users who draw themes themselves.
Changed
-
The website's home page has a fourth promise, the themes, and the docs say how to choose one.
-
Every tool's
--themehelp points tognux theme, and thegnux theme listpanel suggestsgnux theme set NAMEto keep a theme. The website's/docs/themespage is now/docs/theme(the old address redirects). -
The website builds on Node.js 26 (the current LTS):
web/package.jsonpins"node": "26.x", so Vercel no longer moves it to a new major version on its own, and CI sets up Node.js 26. pnpm moves to 12.16.1, which records itself inweb/pnpm-lock.yamlso every install uses that exact release.
Fixed
syncx FILEon Windows no longer fails withPermission denied: Windows flushes a file only through a handle open for writing, so a refusal on GNU's read-only handle is retried on a write-only one.pathchkxon Windows reportsNot a directoryfor a name under a regular file (file/x), as on POSIX systems, instead of passing it as a name that could be created.- The test suite passes on Windows again: tests no longer expect unquoted absolute paths
(
C:holds a:, which GNU quotes), a fixed:list separator, or a permission mode Windows cannot store.
1.4.0 - 2026-11-03
gnux 1.4.0 gives the tools people read a terminal view, and closes the largest gaps with GNU
grep and sed. On a terminal the output is colored, framed and fitted to the screen, in a
built-in theme after an editor theme that follows the system's light or dark appearance; this
is the default for every tool that has a view. Through a pipe or into a file the output is
GNU's exactly as before, so scripts, $(...) and the conformance harness see no change. Back
references (\1 to \9) now work in every tool that takes a regular expression, and
grepx -P takes Perl syntax with lookahead and lookbehind. gnux shell gains read and the
POSIX ${...} expansions, gnux help draws the gnux mark on a terminal, and the website builds
in half the memory. There is no 1.3.0 release: a v1.3.0 tag was pushed on 2026-11-02 before
this work was merged, and its release never ran; Go's module proxy serves that tag, with the
code of 1.2.0, so this release takes the next minor version to be the newest everywhere.
Added
- A terminal view for the tools people read, on by default on a terminal and never through a
pipe, so scripts still get GNU's output (BR-13, NFR-53, NFR-54).
--pretty[=WHEN]andGNUX_PRETTYchoose it,--theme=NAMEandGNUX_THEMEpick a built-in theme with single colors overridden by two-letter keys, andNO_COLORkeeps it uncolored. - Built-in themes after editor themes, most in a dark and a light variant (
vscode,github,one,solarized,gruvbox,catppuccin,tokyo-night,ayu,rose-pine,everforest,night-owl,high-contrast); the family's name follows the background, read fromGNUX_BACKGROUND,COLORFGBGor the system's dark mode (macOS, Windows, GTK). Alsodracula,nord,monokai,kanagawa,palenight,ayu-mirage,defaultandmono. gnux themes: every built-in theme drawn on a sample row, with the theme in use and the background gnux read (FR-184).lsx: the long format colored column by column, with a header, readable sizes and directories first in the view;--treeand--level(also for-R),--icons(Nerd Font,GNUX_ICONS),--gitand--git-ignore(read from the repository without running git),--color-scale,--only-dirs,--only-files,--total-sizeand--octal-permissions.dfx: a framed table that fits the terminal, with a usage bar after each percentage, turning yellow from 75% and red from 90%.findx: on a terminal, each name-printwrites in its type's color, aslsxshows it, and the directories before it dimmed;--treedraws the matches as a tree under each starting point with a count, and--iconsputs an icon before each name. Both go before the starting points;-print0,-printfand-lsare unchanged.ddx status=progressrewrites GNU's transfer line once a second while copying (it printed only the final statistics); on a terminal it draws a bar with the percentage, the rate and the time left.gnux shell: on a terminal, the prompt shows the working directory and the status of a command that failed, andhelpis colored.--prettyand--themeon the shell apply to every tool it runs.datexshows one date as a panel: local time, UTC, ISO 8601, Unix seconds, the week and day of the year, the zone, and how far it is from now.unamexshows the system as a panel. On a terminal by default like every other view;$(datex)and$(unamex -r)are captured through a pipe, so scripts still get GNU's one line.commx: on a terminal, a header row naming the files, and each column's lines in a color of their own.joinx: each field colored by the file it came from, the join field apart. New theme keysf1,f2,fb.killx -land-L: on a terminal, every signal in a framed table, the names colored by what the signal does.sttyx -a: a panel with the control characters in a grid and each group of flags on its own lines, the flags that are off dimmed.envxandprintenvx: on a terminal, a listing of the environment has the names colored apart from the values, and the directories ofPATH(and every*PATHvariable) set apart. New theme keyev.whoxandpinkyx: on a terminal, framed tables with a header and your own logins emphasized, andpinkyx -las a panel per user;idxas a panel of your IDs and groups;usersxandgroupsxwith your name and primary group emphasized.uptimex: on a terminal, a panel with each load average drawn as a bar against the CPU count, turning yellow and then red as the machine fills up.odx: on a terminal, each value colored by the class of its bytes (zero, printable, whitespace, other control characters, above 0x7f), and the offsets dimmed, so the structure of a binary file shows at a glance. New theme keysyz,yp,yw,ycandyh.uniqx -c: on a terminal, a histogram, with each count colored by its share of the largest and a bar before the line, sosortx | uniqx -cshows how values are spread.shredx -v: on a terminal, each pass is one line with a bar, rewritten in place.wcx: the counts as a framed table with a header and the total set apart.statx: each file as a labeled panel, the mode painted; with-f, a bar of the space in use.dux: aligned sizes colored by magnitude, with a bar and percentage of each line's share.grepx: each file's matches under a colored heading of its name, numbered, with a blank line between files.md5sumx,sha1sumxtosha512sumx,b2sumx,cksumx: with-c,OKandFAILEDcolored and a count after each list.headx,tailx: the==> FILE <==headers colored.rmx,cpx,mvx,lnx,installx,mkdirx,rmdirx,chmodx,chownx,chgrpx: the-vreport colored (the verb, each name, the arrows).- The playground shows the terminal view: the scrollback is a terminal to the tools, so they
draw their view there while a pipe or a redirection still gets GNU's output. A theme picker
in the side panel (kept in the link as
?theme=) draws the scrollback in the editor theme's own background and colors, a family following the page's light or dark theme, andCOLUMNSfollows the terminal's width. The WebAssembly API gainsthemes,setenvandsurface(FR-186). - The guide Terminal view, and how each tool adopts
the view in
docs/workflows/terminal-visuals.md. - Back references in regular expressions:
grepx '\(.\)\1',grepx -E '(ab)\1',sedx 's/\(\w*\) \1/\1/g',exprx abab : '\(.*\)\1', and innlx,csplitx,findx -regexandptxx. A pattern with one runs on a new backtracking matcher (core/internal/regex) behind the same interface as Go's engine, which keeps every other pattern in linear time. POSIX's leftmost-longest match is kept,-ifolds the referenced text, and a search that would take exponential time is given up after a step budget and reported (status 2 for grepx, 4 for sedx), never taken as "no match". A reference to a group that does not exist is GNU'sInvalid back reference. grepx -P(--perl-regexp): Perl syntax as Go's engine has it (\d,\w, lazy quantifiers,(?i), named groups,\Q...\E), plus back references (\1,\g{N},\g{-N},\k<name>), lookahead and lookbehind ((?=...),(?!...),(?<=...),(?<!...), of any length),\h,\v,\R,\N,\Z,\e,\cXand(?#comments), matching the first match as Perl does. What it cannot run is refused by name: possessive quantifiers, atomic groups, recursion, conditionals,\K,\G,\X.-Fbeats-P, which beats-Eand-G.gnux shell: theread [-r] [NAME...]builtin, sowhile read -r line; do ...; done < fileand... | while read a b; do ...; donework. It splits at$IFS, gives the last NAME the rest of the line, usesREPLYwith no NAME, and reads one byte at a time so that the next command gets the rest of the input.gnux shell: the POSIX parameter expansions${#NAME},${NAME#pat},${NAME##pat},${NAME%pat},${NAME%%pat},${NAME-w},${NAME=w},${NAME:=w},${NAME+w},${NAME:+w},${NAME?msg}and${NAME:?msg}, beside${NAME:-w}. Their word may hold quotes and blanks (${X:-"a b"}) and nested expansions (${A:-${B}}).- Tests for the packages that had none:
fnmatch(with a fuzz target held topath.Match),ownership,sysstat,special, and theexprx,testx,ddxandhostidxcommands. - A rule for working on the repository: everyday command-line work uses gnux itself (
rmx,cpx,grepx,sedx,findx, ...), and a difference from GNU found that way is fixed, not routed around (docs/rules/work-in-the-repository-with-gnux.md). gnux help(andgnux --help, andgnuxalone) draws the gnux mark on a terminal, the website's keycap with its prompt and spanner in half blocks, with the version and where to go next beside it. Help read through a pipe still starts with GNU'sUsage:line.
Changed
- Every terminal view is on by default on a terminal,
datexandunamexincluded (they were shown only with--pretty):$(datex)and a redirection are not a terminal, so scripts still get GNU's output.GNUX_PRETTYnow applies to them as to every other tool. - Dependencies: the Go modules, the website's packages (Next.js 16.4.4, Fumadocs 16.17.9,
TypeScript 6.0.3, eslint 10.14.0 and the rest) and every GitHub Action are on their newest
releases. The docs content schema comes from
fumadocs-core(pageSchema), replacing the deprecatedfrontmatterSchema. - The website keeps one set of docs per major version, the newest release's (its latest minor
and patch), instead of one per minor release: the latest docs are v1's, and older major
versions (v0) get their own under
/docs/vN. Links to the old per-minor addresses (/docs/v1.1/...) redirect to the latest docs.tools/docsnapnames a release's docs after its major version; the website still reads the archives of earlier releases. - The website's build no longer runs out of memory (SIGKILL on an 8 GB build machine): only the
latest docs are prerendered, an older version's pages and the Open Graph images render on
their first visit and are cached, the MDX is loaded per page,
pnpm builduses webpack, which peaked at 4.5 GB where Turbopack passed 8 GB, and at most four workers render the pages. A build makes 1,174 pages, not 7,734, in well under half the time.
Fixed
xargsx -P: a command that exits with status 255 stops the run at once, as GNU's does. On one CPU, with gnux's own tools (which run in-process and finish at once), thousands more commands could run after it, because Go ran the newest command first; commands now start in order.gnux shell:2>&1and>&2(and1>&2) now duplicate a stream, as in sh, instead of writing to a file named&1or&2;1>and1>>redirect standard output instead of passing1as an argument.gnux shell: a lone&is a syntax error ("background jobs (&) are not supported") instead of an argument, and so is any other>&N.gnux shell: a${...}form the shell does not have (bash's${x/a/b},${x:1}) is reported as a bad substitution and stops the script, where any form but${NAME:-w}used to expand to nothing; an unclosed${xis a syntax error.- The documentation generator no longer deletes the docs of an older major version
(
web/content/docs/v0) when it regenerates the latest ones.
Security
- Releases are built with Go 1.26.10, named by a new
toolchainline ingo.mod. They were built with Go 1.26.0, whose standard library has eight vulnerabilities reachable from gnux (inos,net,archive/tarand system calls) that later 1.26 releases fixed; govulncheck now reports none on any release platform. - The container image runs on Alpine 3.24 (supported until 2028); it ran on Alpine 3.20, whose support ended in April 2026. Trivy finds nothing in the image.
- The workflows: every action is pinned to a commit SHA and on its newest release; no checkout keeps its git credentials but the job that pushes the major version tag; the release jobs no longer restore caches, which another run could have poisoned; and the setup-gnux action accepts only a release tag as its version, where a crafted one could add step outputs. zizmor reported 5 high and 14 medium findings; it now reports none.
- The website's build refuses a downloaded docs archive holding a path that climbs out of its folder or a link, before unpacking it.
- A new Security workflow runs govulncheck on every release platform,
pnpm audit, zizmor, gitleaks over the history and CodeQL on the Go, TypeScript and workflow code, on every change and weekly.SECURITY.mdsays how to report a vulnerability privately. - Checked and found sound: the macOS sandbox profile quotes the paths it is given (a test now holds it to that), launchd will not start a job for a sandboxed command, the MCP server keeps a call's directory inside its roots, and the tools that make temporary names create them exclusively.
1.2.0 - 2026-10-21
gnux 1.2.0 completes GNU coreutils: the last fourteen tools arrive, so every coreutils tool is
in gnux but chroot, chcon and runcon, which stay out by design, 108 tools in all. Each new
tool is checked against GNU coreutils 9.7 by the conformance harness, 139 new cases. The
reference is no longer committed but built where it is used, and the website now serves it as
YAML for AI tools and scripts.
Added
basencx: base64, base64url, base32, base32hex, base16, base2 (either bit order) and Z85, encoding and decoding, through the enginebase64xandbase32xshare.numfmtx: GNU numfmt's conversions to and from 1.5k, 2.0Mi and the like, with its rounding methods, padding, field selection,--format,--invalidmodes and diagnostics.prx: GNU pr's pages, headers and footers, columns down (balanced) or across, files side by side with-m, line numbering, separators, tab handling and page ranges, reading its command line as GNU's getopt does.ptxx: GNU ptx's permuted index, in the dumb, roff and TeX formats, with references, word lists, break files and the Emacs regular expressions it uses.sttyx: GNU stty on Linux, macOS and FreeBSD, with each system's modes, control characters, speeds, window size,-a, and-gthat reads back.shredx: GNU shred's passes,-uwith its renaming before removal,-vprogress,-x,-z,-sand--random-source.dircolorsx(with GNU 9.7's color database),pinkyx,pathchkx,syncx,mkfifox,mknodx,hostidxandstdbufx(gnux tools run in-process; other programs get GNU'slibstdbuf.sowhen it is installed).- Each release carries its own website docs,
gnux-docs-vX.Y.Z.tar.gz, packed by GoReleaser with the tag's generator and listed in the signedchecksums.txt. The website's build downloads the archive of the latest patch of every minor version, checks it and unpacks it for the version picker (web/scripts/docs-versions.mjs), so the docs of past releases are no longer committed tomainand the release no longer pushes a snapshot commit there. SetGITHUB_TOKENwhere the website is built to keep its one API call off the shared rate limit. - The reference as YAML on the website, one file per page at
/reference/yaml/(for example/reference/yaml/rmx/index.yaml), all of them listed inllms.txt, so AI tools and scripts can read each tool's options and examples as data.
Changed
- The generated reference is no longer committed.
documentation/markdown,man,yamlandrest, and the website's pages inweb/content/docs, are built where they are used: the website build generates its pages, GoReleaser the man pages it ships, and the Docs workflow generates everything, tests the generator and keeps the markdown and man reference as a run artifact.make docsstill writes them all locally. The pre-push hook andmake docs/check, which compared committed copies, are gone. The hand-written guides link to reference pages by their website address, which works on GitHub and stays on the site when read there.
Fixed
- In the docs sidebar, a tool with no option pages is a plain link rather than a folder with
nothing to open, in the docs of past releases too (
tools/docsnapflattens such folders). - The Git hooks clear a
GOROOTleft over from another Go installation, which made the lint compile with the wrong toolchain. - The Homebrew cask clears the quarantine flag with Homebrew's declarative
postflight_stepsinstead of the deprecatedpostflightblock, sobrewno longer warns about the tap.
1.1.0 - 2026-10-19
gnux 1.1.0 adds nine tools and closes most of the gap with GNU's option surface: backups in
cpx, mvx, lnx and installx, every GNU ls option but -f and -Z (GNU's ten quoting
styles, --zero, --hyperlink, --dired, --block-size, ...), GNU's getopt rules for every
option, and the options
chgrpx --from, chmodx -h, datex --resolution, cpx --remove-destination, mvx --no-copy,
tailx --max-unchanged-stats and sortx -R. Every one of them is now checked against GNU
coreutils itself by a conformance harness that runs in CI.
It also brings gnux to npm (npm install --save-dev gnux), a kernel-enforced sandbox for
gnux shell on Linux, macOS, Windows and FreeBSD, gnux mcp to give an AI agent the tools
inside that sandbox, a WASI build, and documentation for each release on the website.
Added
-
gnux on npm:
npm install --save-dev gnuxputs every tool on the PATH of a project's package scripts, under its gnux name (rmx, neverrm), so one dependency replaces rimraf, mkdirp, cpy-cli, shx and cross-env on every platform. The native binary comes in a package per platform (gnux-linux-x64,gnux-darwin-arm64,gnux-win32-x64, ...) that npm installs as an optional dependency, with no install script;require('gnux')offersrunandbinaryPath, andGNUX_BINARYpoints the launchers at another gnux. The Release workflow publishes them with provenance whenNPM_TOKENis set;make npm/packbuilds them locally. The Node and npm guide covers package scripts, globs on Windows and the JavaScript API. -
Documentation for each release on the website: a version select in the docs sidebar switches between the latest docs and those of every stable release as it shipped (
/docs/v1.0/...), staying on the same page when that version has it. Older versions say so at the top of each page and are left out of search, the sitemap andllms.txt. The Release workflow snapshots each stable release's docs withtools/docsnap(make docs/snapshot TAG=vX.Y.Z). -
gnux builds for WASI (
GOOS=wasip1,make wasi): the tools that only read and write files run under a WASI runtime, which lets them reach only the directories it opens. -
gnux shell --sandbox DIR [--sandbox-read DIR]: the script, and every program it starts, can read and write DIR, read the system's directories, and reach nothing else, enforced by the kernel: Landlock on Linux, Seatbelt on macOS, an AppContainer on Windows and Capsicum on FreeBSD. Where no sandbox can be used it refuses with status 125 rather than run unconfined. -
For Go callers:
core/fsys, through which every engine now reaches the file system. By default it is the os package;fsys.Use(fsys.NewRooted(...))confines every engine to a set of directories throughos.Root, in any program. -
gnux mcp DIR...: a Model Context Protocol server inside that sandbox, so that an AI agent (Claude Code, Claude Desktop, Cursor, VS Code) can run gnux command lines in a project and reach nothing outside it, each call with a time limit and an output limit. The Sandbox and AI agents guide covers both. -
Four more coreutils tools.
archxprints the machine architecture, asunamex -mdoes.factorxprints the prime factors of each number, with no size limit, and-h(--exponents) writes repeated factors asp^e.sumxprints the BSD checksum (or, with-s, the System V one) and block count of each file.tsortxsorts pairs of strings topologically, in GNU's order, and names the strings of any loop it finds. -
For Go callers:
cksum.BSDandcksum.SysV, the two legacy checksums on anyio.Reader, anduname.System, the system informationunamexprints. -
Five more coreutils tools.
dirxandvdirxarelsxwith GNUdirandvdir's defaults: columns or the long format whatever the output is, and names with unprintable characters escaped.groupsxprints the groups of the process or of each user named.usersxprints the users logged in.lognamexprints the name the user logged in as, which stays the same undersuandsudo. -
[ EXPRESSION ]: the test tool answers to[, with the closing]required, asgnux [ ... ]and as a link named[, as it already did ingnux shell. -
testx -l STRING: the length of STRING, for either side of an integer comparison, as in GNU test. -
For Go callers:
id.Self,id.LookupUser,id.GroupNameandid.GroupList, andls.NewAs, an ls engine whose diagnostics carry another name. -
Docker images on GHCR with every release:
ghcr.io/braswelljr/gnux(Alpine) and the same tags with-scratchappended, gnux and its links alone in aFROM scratchimage, for linux/amd64 and linux/arm64. -
Every release archive has an SPDX SBOM beside it, and
checksums.txtis signed with cosign (keyless,checksums.txt.sigstore.json). -
core.Diag.ChildErr, the error stream for a child process that runs while diagnostics may still be written. -
Long options may be abbreviated to any unambiguous prefix in every tool (
rmx --rec), as GNU's getopt allows; an ambiguous one lists its possibilities. -
A GNU conformance harness:
make conformance(ormake conformance/docker) runs each case incmd/testdata/conformance/through the GNU tools and through gnux and compares output, errors and exit status; CI runs it on every change. -
Fuzz targets for the parsers of
printfx,seqx,trxandcutx. -
GNU options that were missing:
chgrpx --from=CURRENT_OWNER:CURRENT_GROUP;chmodx -h(--no-dereference) and--dereference, from GNU chmod 9.6 (a link that is not followed has its own mode changed where links have one, and is reported as unchanged on Linux);datex --resolution, and%-Nprinting as many digits as the clock's resolution needs;cpx --remove-destination;mvx --no-copy;tailx --max-unchanged-stats(validated; tailx already checks a followed name on every poll); andsortx -R(--random-sort,--sort=random) with--random-source=FILE, which orders exactly as GNU sort does for the same FILE. Each has GNU conformance cases incmd/testdata/conformance/gnu-options.txt. -
Backups in
cpx,mvx,lnxandinstallx:--backup[=CONTROL](none,simple,existing,numberedand their synonyms),-b, and-S/--suffix, withVERSION_CONTROLandSIMPLE_BACKUP_SUFFIX, as in GNU: the same backup names,-vlines and refusals, checked against GNU incmd/testdata/conformance/backups.txt. For Go callers,core.Backupmakes and names backups, andcore.ParseBackupControlreads a CONTROL word. -
The rest of GNU ls's options in
lsx,dirxandvdirx:--quoting-stylewith all ten of gnulib's styles,-N(--literal) and theQUOTING_STYLEvariable,--show-control-chars,--format,--indicator-style,--zero,--block-sizewithLS_BLOCK_SIZEandBLOCK_SIZE,-k(--kibibytes),--author,--hyperlinkand-D(--dired), each settled by option order as GNU does and checked against GNU incmd/testdata/conformance/ls-options.txt.
Changed
lsxon a terminal quotes names for the shell, as GNU ls has since 8.25:'a b','new'$'\n''line', with unquoted names moved a column right to line up with quoted ones. Use-N(orQUOTING_STYLE=literal) for the old output. For Go callers,ls.Quoting's zero value is nowls.QuoteAuto, GNU's default, andls.QuoteLiteralis-N.- Option errors are worded as GNU's getopt words them in every tool:
unrecognized option '--foo',invalid option -- 'z',option requires an argument -- 'n',option '--force' doesn't allow an argument. findxreports a mistake in its expression without theTry 'findx --help'line, as GNU find does; the status is still 1.chmodx -Panswers to--physicalinstead of--no-dereference, which is GNU's long name for-hand now means that.mktempx -panswers to--base-dirinstead of--dir, which is GNU's abbreviation of--directoryand now means that.- On the website, a tool without options is a single page in the sidebar rather than a folder
with nothing to open; its address,
/docs/tools/<tool>, is unchanged. - Building gnux needs Go 1.26, which
go.modhas required sincegolang.org/x/crypto0.57; the Dockerfile and the documented requirements say so now.
Fixed
tailx -Fon Windows keeps following a file that another process briefly holds without sharing it (an editor saving it, a rename over it): it used to report the file inaccessible and, without--retry, stop.lsx -lwith files and directories as operands sizes the files' columns to fit the directories too, as GNU does:ls -l a.txt dirpadded the size column to the file alone.nicexno longer races with the command it runs over a shared error stream that is not a file (agnux shellpipeline, the playground, an embedding program): its warning and the command's own error output used to be written from two goroutines at once.sortx -greads hexadecimal numbers asstrtolddoes (0x10is 16).wcxkeeps its column width when an operand cannot be read, as GNU 9 does.rmx .without-rreportsIs a directory, andrmx -d .tries and fails, as in GNU; only-rrefuses.and..by name.grepx '['reportsInvalid regular expression, as GNU grep 3.11 does.chownx -R --dereferenceandchgrpx -R --dereferencewithout-Hor-Lno longer add aTry '... --help'line to the error, as GNU does not.chmodx -vreports'FILE' could not be accessedfor a file it cannot reach, as GNU does.lsx: an invalid word for an option (--sort=x,--color=x,--time=x) exits 1, as GNU does, not 2; the error lists synonyms on one line ('always', 'yes', 'force') and--sort's words in GNU's order. A diagnostic quotes a name as GNU's does.statx -c %Nquotes every name, and a link's target, as GNU does ('a.txt',"it's",''$'\001'), in the styleQUOTING_STYLEnames; the default format names files as they are (File: a b), where it used to quote them.lnxnames a directory it refuses as GNU does, quoted only when the name needs it (lnx: e: cannot overwrite directory).- The Docker image builds again: it used Go 1.25, older than
go.modrequires.
1.0.0 - 2026-10-14
gnux 1.0.0 is the first stable release. From here on the command-line interface of every tool
and of gnux shell, the shell's language, and the Go packages under core/ follow Semantic
Versioning: a change that breaks them waits for 2.0.
The headline is gnux shell, which can now run a real script: it branches, loops, takes
arguments and reads the output of a command, the same way on Linux, macOS and Windows.
Added
- Control flow in
gnux shell:if/elif/else/fi,for NAME in WORD...; do ...; done(over the script's arguments wheninis left out),while ...; do ...; doneandcase WORD in PATTERN | PATTERN) ... ;; esac, on one line or over several, withbreak [N]andcontinue [N]. A whole construct can be redirected or piped. - Command substitution,
$(command). Unquoted, its output becomes one word per line, never one per space, so file names with spaces survivefor f in $(findx ...); quoted, it is a single word. It runs as a subshell: variables it sets and acdit makes end with it. - Script arguments:
gnux shell SCRIPT ARG...andgnux shell -c STRING NAME ARG...reach the script as$1,$2, ...,$#,$0,"$@"and$*, with the builtinsshift [N]andset -- ARG.... gnux shell -u, andset -uinside a script: expanding a variable that was never set stops the script withgnux: NAME: unbound variableand status 1.${NAME:-default}reads one that may be missing.! commandinverts an exit status,[ EXPRESSION ]runs thetesttool, andset -e/set +eturn-eon and off from inside a script.- An interactive session continues an unfinished
if, loop orcaseon the next line, at the prompt>. - For Go callers of
core/shell:Options.NoUnset,Shell.SetArgs,Shell.LoopLimit,ContinuePromptandIncomplete. - On the website's home page, taking the keyboard now runs what is typed: Enter hands the line to the real gnux, loaded in the browser as the playground loads it, and the up and down arrows bring back earlier lines. Nothing is downloaded until the keyboard is taken. Once it is, the drawn keys can be clicked as well, with shift and caps lock held by the board.
- The playground offers loops and conditions among its examples, and stops a loop that would never end after 10,000 turns instead of freezing the tab.
Changed
gnux shell SCRIPT EXTRAandgnux shell -c STRING EXTRAare no longer usage errors: the extra operands are the script's arguments. Options are read only beforeSCRIPT.(and)are syntax ingnux shell. Quote them where a tool expects them:findx . '(' -name a -o -name b ')'.$1to$9,$#,$@,$*and$0are expanded ingnux shell; they used to be literal text. Write\$1or use single quotes for the characters themselves.- With
gnux shell -e, the condition of anifor awhileand a command after!may fail without stopping the script, as in sh. - In
gnux shell, the value of an assignment is never globbed (X=*stores*), a leading~in it is the home directory (X=~/bin), andA=1 B=$Aon one line givesBthe newA. - The shell's own diagnostics about a command (
command not found, a redirection that cannot be opened) go to that command's standard error, so2>captures them. - The keyboard on the website's home page is the visitor's own: an M5 MacBook Pro's on an Apple device (icons over the F names, symbols on tab, caps lock, shift, delete and return, the globe on fn, each modifier's symbol over its name) and the latest Microsoft Surface Laptop's, with the Copilot key, anywhere else.
- The home page's monitor and keyboard are sized to fit the viewport together, and every animated terminal on the site fills from the top down, as a real one does.
0.0.2 - 2026-10-13
gnux grows from 22 tools to 85: nearly all of coreutils, plus grepx, sedx, findx and
xargsx for the scripts that need more than coreutils. Releases now cover nine platforms and
reach Homebrew, Scoop, winget, the Snap Store, the AUR and .deb / .rpm / .apk packages.
Added
- 59 more coreutils tools:
- text:
sortx,uniqx,cutx,trx,teex,seqx,printfx,pastex,joinx,commx,nlx,foldx,fmtx,expandx,unexpandx,tacx,splitx,csplitx,shufx,odx; - checksums and encoding:
md5sumx,sha1sumx,sha224sumx,sha256sumx,sha384sumx,sha512sumx,b2sumx,cksumx,base32x,base64x; - file attributes:
chmodx,chownx,chgrpx,statx,dux,dfx,mktempx,installx,truncatex,readlinkx,linkx,unlinkx; - system:
datex,unamex,whoamix,idx,hostnamex,nprocx,printenvx,ttyx,whox,uptimex,timeoutx,nicex,nohupx,killx,testx,exprx,ddx.
- text:
- Four tools from beyond coreutils, the ones a build or CI script reaches for next:
grepx(GNU grep),sedx(GNU sed), andfindxandxargsx(GNU findutils). Each mirrors its GNU counterpart's options, diagnostics and exit statuses, and lists what it does not implement on its reference page.grepx: basic, extended and fixed-string patterns, context lines, recursive search with--include/--exclude/--exclude-dir, counts, file lists,-o, colors.sedx: the whole script language (addresses,swith its flags and case conversions, hold space, branches,a/i/c,r/w) and in-place editing with-i[SUFFIX].findx: the expression language with its operators, the name, type, size, time, permission and owner tests,-printf,-delete,-prune, and-exec/-execdir/-ok.xargsx: quoting,-0,-d,-n,-L,-I,-P,-p,-t,-r, and GNU's exit statuses 123 to 127.- Patterns in
grepx,sedxandfindx -regexare matched by Go's RE2 engine, which runs in linear time but has no back references: a pattern that uses one (\(a\)\1) is refused with a message instead of being matched differently.sedxrefuses itsecommand, andgrepxrefuses-P.
xargsxandfindx -execrun a command named after a gnux tool in-process, sofindx . -name '*.map' | xargsx rmworks on a machine with no GNU tools installed, Windows included, and insidegnux shell. Any other command is a program found onPATH.- Where GNU has a known rough edge, the new tools fix it and document it:
duxreads directories in parallel and lists them in a stable order; recursivechmodx,chownxandchgrpxrefuse/by default;nicexmaps niceness onto Windows priority classes andnohupxdetaches from the console on Windows, so both work there;killx 1234 -9never signals process group 9;dfx,whox,uptimexandstatxreport the same fields on Linux, macOS, FreeBSD and Windows without cgo. - Releases built by GoReleaser (
.goreleaser.yaml), for four more platforms (linux/riscv64,freebsd/amd64,freebsd/arm64,windows/arm64), with shell completions in every archive and a build provenance attestation. Archive names are unchanged. - Package managers, published with each release: a Homebrew cask and
a Scoop manifest, both served from this repository (
Casks/,bucket/), winget manifests, a snap (snap install gnux), an AUR package (gnux-bin), and.deb,.rpmand.apkpackages attached to the release for Debian, Ubuntu, Fedora, RHEL, openSUSE and Alpine. - setup-gnux, a GitHub Action (
uses: braswelljr/gnux@v0) that installs a checksum-verified release on Linux, macOS and Windows runners and puts every tool onPATH. gnux completion bash|zsh|fish|powershell, listed ingnux --help.- Documentation examples can show their output (
docmeta.Example.Output), rendered under the commands in every reference page. - Website: an install page with copyable steps per platform (macOS, Windows, Linux and FreeBSD, Go, GitHub Actions, Docker); a pausable marquee of every tool; a "why gnux" strip; and, on every tool page, a GNU reference and examples with bash and PowerShell tabs that remember your choice.
- Library:
core.FlushOutput, which reports a failed final write (write error: No space left on device) instead of exiting 0;core.NewReader,core.NewWriterandcore.BufferSize, the buffering every tool shares;core.Trap, which carries a panic on a tool's own goroutine back to its caller; andshell.Shell.Glob, the injection point for globbing. - A benchmark suite over the real tools:
make benchreports throughput and allocations for each tool on generated text, a directory tree and shell pipelines;make bench/saveandmake bench/comparecompare two runs, andmake bench/checkfails when a benchmark got slower or allocates more, which the new Bench workflow runs on every pull request against its base commit. - Fuzz tests for every parser (the shell,
sedxscripts,grepxpatterns,findxexpressions,xargsxinput), run in CI and withmake fuzz.
Changed
gnux TOOLstarts as fast as the tool does under its own name: a first argument that names a tool runs it directly, without building the root command and every other tool's flags first.gnux shellno longer builds every tool's command before reading a script, nor rebuilds the tool list for each command it runs.- A filter answers each line as it gets it:
catx -nandheadx, like the newnlx,cutx,trx,foldx,expandx,unexpandx,pastex,uniqx,grepxandsedx, pass their output on whenever their input has run dry, instead of holding it until a buffer fills. Behindtail -f, a build log or a terminal they no longer look hung; on bulk input nothing changes. - A tool that panics is reported as
TOOL: internal errorwith status 2 instead of ending the process, so one tool's bug does not take a shell pipeline, the playground or an embedding program down with it. That holds for a panic on a goroutine the tool started too (rmxworkers,dux,xargsx -P, a pipeline stage). - Running a tool with tens of thousands of arguments, as
xargsxandfindx -execdo, no longer scans them several times before the tool starts: about 20 times less memory for such a call, and a third less work for every call. - Every tool reads and writes through 64 KiB buffers where it used 4 KiB ones;
catx -nis about twice as fast on large inputs, with the same output. - Release tags must be full versions (
v1.2.3,v1.2.3-rc.1); each stable release moves its major tag (v0), which the GitHub Action is used by. - Dependabot also updates the website's pnpm packages.
0.0.1 - 2026-10-11
Added
- 22 GNU-compatible tools in one multi-call binary,
gnux:basenamex,catx,cpx,dirnamex,echox,envx,falsex,headx,lnx,lsx,mkdirx,mvx,pwdx,realpathx,rmx,rmdirx,sleepx,tailx,touchx,truex,wcxandyesx. Each runs as its own name, as its GNU name through a link, or asgnux <tool>, with GNU's flags, diagnostics and exit statuses. gnux shell, a small portable POSIX sh subset whose commands are the tools, run in-process, so one script behaves the same on Linux, macOS and Windows.- Every tool's engine as an importable Go package under
core/, pluscmd.RunToolandcmd.NewShellfor running tools and scripts from Go. gnux help TOOL [OPTION]for a tool's full manual, or one option in depth.- The reference in markdown, man, YAML and reStructuredText under
documentation/, generated from the code and checked in CI. - A website with the documentation, a page for every option of every tool, and a playground that runs the real gnux, compiled to WebAssembly, on an in-memory filesystem.
- Release archives for Linux and macOS (amd64, arm64) and Windows (amd64), with a checksums file.
Changed
- The project is now gnux, a portable implementation of the GNU core utilities.
rmx, which it started as, was rewritten as one of its tools, with GNU's fullrmflag surface.
Go library
Use the gnux engines, tools and shell from a Go program.
Adoption
How to adopt gnux next to the GNU coreutils you already know. gnux does not replace them: it brings the same interface to the places they are missing (Windows, containers without coreutils, the browser, Go programs), so the GNU tools stay where they are and gnux is added where it helps. This guide sets the two side by side: how each of the 108 gnux tools maps onto its GNU counterpart, which flags it supports, every documented deviation (the places where gnux must choose differently because it cannot see option order, or because Windows cannot express a feature), the GNU options that are not implemented yet, the places where gnux deliberately does better than GNU, and the three coreutils tools left out by design. If a behavior is not listed here as a difference, gnux aims to match GNU exactly, down to the wording of its diagnostics and its exit statuses.