Skip to content
Get packs

Guide · Open source

How to use uutils coreutils: build, install and run

Updated · written with AI from the project's own documentation and checked against our catalogue data

uutils coreutils is a cross-platform reimplementation of the GNU coreutils, the everyday command-line programs such as ls, cat, cp and rm, written in Rust. This guide is for people who want to try it as a drop-in replacement or use it on platforms where GNU tools are not available. By the end you will know what you need installed, how to clone and build it with Cargo or GNU Make, and how to install it.

uutils coreutilsuutils/coreutils · ★ 24.3k · MIT

Quick start

  1. 1Clone the repository. Run git clone https://github.com/uutils/coreutils and change into the coreutils directory.
  2. 2Check prerequisites. Make sure Rust with cargo and rustc is installed. GNU Make is optional.
  3. 3Build a release binary. Run cargo build --release to produce the multicall coreutils binary.
  4. 4Choose which utilities to include. Use --features with --no-default-features to build only the tools you need, or use GNU Make options.
  5. 5Install. Run cargo install --path . --locked for a quick install, or make install if you want manpages and shell completions.
  6. 6Generate completions (optional). Install uudoc and use uudoc completion with your shell name to write completion scripts.

What uutils coreutils is and what it aims to do

uutils reimplements the GNU coreutils in Rust. The project aims to be a drop-in replacement, and differences from GNU are treated as bugs. Its stated goals include matching GNU's output (stdout and error code) exactly, and supporting UTF-8 internationalization.

The project aims to run on Linux, macOS, *BSD, Windows, WASI and other platforms, so scripts can be moved between them more easily. The README also notes that while all programs have been implemented, some options might be missing or behave differently.

  • Goal: exact GNU output and error codes
  • Goal: work on Linux, macOS, BSD, Windows and WASI
  • Note: some options may be missing or differ from GNU

What you need before you build

You need Rust, which provides cargo and rustc. GNU Make is optional. The README says uutils is tested against Rust's stable, beta and nightly channels.

Building the full package, including all documentation, requires both Cargo and GNU Make on a Unix platform.

  • Rust (cargo, rustc), required
  • GNU Make, optional
  • Full docs build: Cargo and GNU Make on a Unix platform

Clone the repository and build with Cargo

First fetch the source code. Then build a release binary with Cargo. This builds the most portable common core set into a multicall (BusyBox-type) binary named coreutils.

To optimize for binary size, replace --release with --profile=release-small. To build only some utilities, list them as features with --no-default-features.

git clone https://github.com/uutils/coreutils cd coreutils cargo build --release # Build selected utilities only cargo build --features "base32 cat echo rm" --no-default-features

Build with GNU Make

If you prefer Make, the build runs from the same cloned directory. Use PROFILE=release for a release build, or UTILS and SKIP_UTILS to choose which utilities are included.

  • Build all available utilities with the debug profile: make
  • Release build: make PROFILE=release
  • Choose utilities: make UTILS='UTILITY_1 UTILITY_2' or make SKIP_UTILS='UTILITY_1 UTILITY_2'
make PROFILE=release

Install uutils on your system

The simplest install uses Cargo from inside the cloned repository. It places the binaries in Cargo's bin folder, usually $HOME/.cargo/bin. This does not install shell completions or manpages.

To get manpages and shell completions, use GNU Make instead. Running make install installs completions for bash, fish and zsh. The README also lists options such as PREFIX (default /usr/local), DESTDIR, PROG_PREFIX and MULTICALL.

  • Cargo install: no manpages or completions
  • make install: includes manpages and completions for bash, fish and zsh
  • make install with MULTICALL=y installs the multicall binary
  • make COMPLETIONS=n MANPAGES=n install skips completions and manpages
cargo install --path . --locked # or with GNU Make make install sudo -E make install

Generate shell completions manually

The uudoc binary generates completions for bash, elvish, fish, powershell and zsh and prints them to stdout. Install it first, then redirect the output to the completion file your shell uses.

cargo install --bin uudoc --features uudoc --path . uudoc completion ls bash > /usr/local/share/bash-completion/completions/ls

What people use it for

  • Trying a Rust-based drop-in replacement for GNU coreutils on a Linux machine
  • Building a minimal BusyBox-style multicall binary for a small or embedded system
  • Writing cross-platform scripts that use the same utilities on Linux, macOS, BSD and Windows
  • Contributing to Rust systems programming and GNU compatibility work

Frequently asked questions

Is uutils coreutils free to use?

Yes. The project is licensed under the MIT licence, as shown in the repository's badge and LICENSE file. The source is available on GitHub.

What do I need to install uutils coreutils?

You need Rust, which provides cargo and rustc. GNU Make is optional. Clone the repository and build with cargo build --release.

Can uutils coreutils replace GNU coreutils?

It is designed as a drop-in replacement, but the README says some options might be missing or behave differently. Users who need exact GNU behavior in every edge case should check the differences first.

Which operating systems does uutils coreutils run on?

The project aims to run on Linux, macOS, BSD, Windows and WebAssembly (WASI). Some platform-specific utilities are enabled with features such as windows or unix.

Why does cargo install not add manpages or completions?

The README says cargo install does not install files for shell completion or manpages. Use GNU Make with make install, or install the completions manually with uudoc.

What are the alternatives to uutils coreutils?

The comparable projects listed are GNU coreutils, BusyBox and Toybox. GNU coreutils is the reference implementation that uutils aims to match.

New agent skills, repos and AI tools — every week

The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.

Our verdict

uutils coreutils suits developers who want to try a Rust-based drop-in replacement, people building minimal systems that need a BusyBox-style multicall binary, and contributors interested in GNU compatibility. If you need guaranteed exact GNU behavior in every edge case, or a fully supported production tool, use GNU coreutils or another established option.

Install options & downloads