Hubbry Logo
GNU Core UtilitiesGNU Core UtilitiesMain
Open search
GNU Core Utilities
Community hub
GNU Core Utilities
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
GNU Core Utilities
GNU Core Utilities
GNU Core Utilities
View on Wikipedia
from Wikipedia

GNU Core Utilities
DeveloperGNU Project
Stable release
9.8[1] Edit this on Wikidata / 22 September 2025
Repository
Written inC, shell script[2]
Operating systemUnix-like
TypeMiscellaneous utilities
License2007, GPL 3.0 or later since version 6.10
2002, GPL 2.0 or later until version 6.9
Websitewww.gnu.org/software/coreutils/

The GNU Core Utilities or coreutils is a collection of GNU software that implements many standard, Unix-based shell commands. The utilities generally provide POSIX compliant interface when the POSIXLY_CORRECT environment variable is set, but otherwise offers a superset to the standard interface. For example, the utilities support long options and options after parameters. This environment variable enables a different functionality in BSD.

Similar collections are available in the FOSS ecosystem, with a slightly different scope and focus (less functionality), or license. For example, BusyBox which is licensed under GPL-2.0-only, and Toybox which is licensed under 0BSD.

Commands

[edit]

The commands implemented by coreutils are listed below. Throughout this article and customary for Unix-based systems, the term file refers to all file system items including regular files and special files such as directories.

File utilities

[edit]
  • chcon – Changes file security context (SELinux)
  • chgrp – Changes file group ownership
  • chown – Changes file user ownership
  • chmod – Changes file permissions
  • cp – Copies files
  • dd – Copies and converts file data
  • df – Reports file system free space
  • dir – Like ls -C -b; by default lists files in columns, sorted vertically
  • dircolors – Configures colors used for ls output
  • install – Copies files and sets file attributes
  • ln – Creates a link to a file
  • ls – Lists files
  • mkdir – Creates directories
  • mkfifo – Creates named pipes (FIFOs)
  • mknod – Creates block or character special files
  • mktemp – Creates temporary regular files or directories
  • mv – Moves and renames files
  • realpath – Reports the absolute or relative path of a file
  • rm – Deletes files
  • rmdir – Deletes empty directories
  • shred – Overwrites a file to hide its contents and optionally deletes it
  • sync – Flushes file system buffers
  • touch – Changes file timestamps; creating files if they do not exist
  • truncate – Sets the size of a file via truncation or extension
  • vdir – Like ls -l -b; by default lists files in long format

Text utilities

[edit]
  • b2sum – Computes and checks BLAKE2b message digest
  • base32 – Encodes or decodes base32
  • base64 – Encodes or decodes base64
  • basenc – Encodes or decodes various encodings including hexadecimal, base32, base64, and Z85
  • cat – Concatenates files
  • cksum – Report or compute the checksum of files
  • comm – Compares two sorted files line by line
  • csplit – Splits a file into sections determined by context lines
  • cut – Removes sections from each line of files
  • expand – Converts tabs to spaces
  • fmt – Formats text
  • fold – Wraps each input line to fit in specified width
  • head – Outputs the first part of files
  • join – Joins lines of two files on a common field
  • md5sum – Computes and checks MD5 message digest
  • nl – Numbers lines of files
  • numfmt – Formats numbers
  • od – Dumps files in octal and other formats
  • paste – Merges lines of files
  • ptx – Produces a permuted index of file contents
  • pr – Paginates or columnates files
  • sha1sum, sha224sum, sha256sum, sha384sum, sha512sum – Computes and checks SHA-1/SHA-2 message digests
  • shuf – Generates random permutations
  • sort – Sorts lines of text files
  • split – Splits a file into pieces
  • sum – Checksums and counts the blocks in a file
  • tac – Concatenates files in reverse order; line by line
  • tail – Outputs the last part of files
  • tr – Translates or deletes characters
  • tsort – Performs a topological sort
  • unexpand – Converts spaces to tabs
  • uniq – Removes duplicate lines from a sorted file
  • wc – Reports the number of bytes, words, and lines in files

Shell utilities

[edit]
  • arch – Reports machine hardware name; same as uname -m
  • basename – Removes the path prefix from a given pathname
  • chroot – Changes the root directory
  • date – Reports or sets the system date and time
  • dirname – Strips non-directory suffix from file name
  • du – Shows disk usage on file systems
  • echo – Outputs text
  • env – Reports and modifies environment variables
  • expr – Evaluates expressions
  • factor – Factors numbers
  • false – Does nothing but exit with unsuccessful status
  • groups – Reports the groups of which the user is a member
  • hostid – Reports the numeric identifier for the current host
  • id – Reports the real or effective UID and GID
  • link – Creates a link to a file
  • logname – Reports the user's login name
  • nice – Modifies scheduling priority
  • nohup – Allows a command to continue running after logging out
  • nproc – Queries the number of (active) processors
  • pathchk – Checks whether file names are valid or portable
  • pinky – A lightweight version of finger
  • printenv – Reports environment variables
  • printf – Formats text
  • pwd – Reports the current working directory
  • readlink – Reports the value of a symbolic link
  • runcon – Run command with specified security context
  • seq – Reports a sequence of numbers
  • sleep – Blocks (delays, waits) for a specified amount of time
  • stat – Reports information about an inode
  • stdbuf – Runs a command with custom standard streams configuration
  • stty – Changes and reports terminal line settings
  • tee – Sends output to multiple files
  • test – Evaluates an expression
  • timeout – Runs a command with a time limit
  • true – Does nothing but exit with success status
  • tty – Reports the terminal name
  • uname – Reports system information
  • unlink – Removes files via unlink() function
  • uptime – Reports how long the system has been running
  • users – Reports the user names of users currently logged into the current host
  • who – Reports logged-in users
  • whoami – Reports the effective userid
  • yes – Outputs a string repeatedly
  • [ – Synonym for test that enables expressions like [ expression ]

History

[edit]

In 1990, David MacKenzie announced GNU fileutils.[3]

In 1991, MacKenzie announced GNU shellutils and GNU textutils.[4][5] Moreover, Jim Meyering became the maintainer of the packages (known now as coreutils) and has remained so since.[6]

In September 2002, the GNU coreutils were created by merging the earlier packages textutils, shellutils, and fileutils, along with some other miscellaneous utilities.[7]

In July 2007, the license of the GNU coreutils was updated from GPL-2.0-or-later to GPL-3.0-or-later.[8]

See also

[edit]


References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

GNU Core Utilities

View on Grokipedia
from Grokipedia
The GNU Core Utilities (commonly known as coreutils) are a collection of free software utilities implementing many of the basic command-line tools expected in Unix-like operating systems, focusing on file management, shell scripting support, and text processing. These tools, such as ls for listing directory contents, cp for copying files, and cat for concatenating and displaying files, provide essential functionality for system administration, scripting, and everyday user tasks. Developed as part of the GNU Project by the Free Software Foundation, coreutils ensures POSIX compatibility while offering GNU-specific extensions for enhanced usability and performance. The package is licensed under the GNU General Public License (GPL) and is a foundational component of the GNU operating system, though it is also integral to most Linux distributions. Originally released as three separate packages—fileutils (handling file operations like chmod and rm), shellutils (providing shell-related commands such as echo and env), and textutils (including text tools like cut and sort)**—the utilities were merged into the unified coreutils package in 2002, with the first release (version 5.0) occurring in 2003. This consolidation streamlined maintenance and distribution, reflecting the GNU Project's evolution since its inception in 1983 to create a complete free Unix-like system. Over time, coreutils has grown to include more than 100 programs, with ongoing development emphasizing bug fixes, security enhancements, and support for modern hardware and filesystems. The current stable version, 9.9, was released on November 10, 2025, as a stabilization release with various bug fixes. Coreutils is maintained by a team including Jim Meyering, Paul Eggert, Pádraig Brady, Bernhard Voelker, and Collin Funk, with source code hosted on the GNU Savannah repository for community contributions. Its design prioritizes portability across platforms, from embedded systems to high-performance servers, and it remains one of the most downloaded and audited GNU packages due to its critical role in secure and efficient computing environments.

Introduction

Purpose and Scope

The GNU Core Utilities, often referred to as coreutils, comprise a collection of over 100 essential Unix-like command-line tools for file management, shell operations, and text processing. Developed as part of the GNU Project, these utilities form a foundational component of the GNU operating system and are indispensable in POSIX-compliant environments, enabling users and scripts to perform fundamental system tasks reliably and efficiently. These tools deliver standardized functionality for common operations, such as duplicating or removing files, analyzing text streams, and controlling process execution, thereby supporting scripting, automation, and interactive use in shells. By providing a consistent interface across diverse systems, coreutils facilitate interoperability and simplify system administration. The package organizes its utilities into three primary categories: file utilities for handling directories and disk usage, text utilities for manipulating and formatting content, and shell utilities for process and environment management. As of version 9.9, released on November 10, 2025, coreutils includes approximately 118 distinct programs, reflecting ongoing enhancements to meet modern computing needs. Coreutils hold critical importance in Linux distributions, where they serve as the core set of binaries for bootstrapping systems and daily operations, and extend to embedded systems owing to their lightweight design and broad applicability in resource-constrained settings. They establish a baseline for POSIX adherence, promoting portability without delving into specific conformance details.

Standards Compliance

The GNU Core Utilities primarily comply with the POSIX.1-2008 standard, providing all required utilities and options necessary for Unix emulation in portable operating system interfaces. This conformance ensures that the utilities behave consistently across compliant systems, supporting essential operations such as file manipulation, text processing, and shell interactions as defined in IEEE Std 1003.1-2008. By default, the utilities align with the POSIX version standard for the host system, but users can enforce stricter adherence by setting the POSIXLY_CORRECT environment variable, which suppresses GNU-specific extensions and enforces POSIX-mandated behaviors, such as precise handling of whitespace in commands like wc. Additionally, the _POSIX2_VERSION environment variable allows selection of specific POSIX versions, including 200809 for POSIX.1-2008, enabling compatibility testing and validation against the standard's shell and utilities volume. Beyond core POSIX requirements, the GNU Core Utilities include extensions that enhance usability while maintaining backward compatibility, such as the ubiquitous --help and --version flags available across most utilities for quick reference and version information. These GNU-specific options do not conflict with POSIX when POSIXLY_CORRECT is unset, allowing flexible operation in diverse environments. Where applicable, the utilities also conform to aspects of the Single UNIX Specification (SUS), particularly in areas overlapping with POSIX.1-2008, such as standardized utility interfaces and error handling, though full SUS certification is not claimed. Internationalization support in the GNU Core Utilities facilitates global use through locale-aware operations and UTF-8 handling. Utilities like printf correctly output Unicode characters in UTF-8 locales, supporting multibyte encodings for languages such as Chinese (e.g., GB2312, BIG5, UTF-8). Locale categories, including LC_CTYPE for character classification and LC_NUMERIC for formatting, ensure operations adapt to regional conventions, such as decimal separators or date formats, promoting portability in internationalized Unix-like systems. Commands like wc count characters based on the current locale's encoding, properly handling UTF-8 sequences while reporting errors for invalid multibyte inputs. Security features in the GNU Core Utilities address common risks in Unix environments, particularly through options that enforce secure file permissions and prevent catastrophic errors. For instance, the --preserve-root option, default since version 6.4, protects the root directory (/) from deletion or modification in utilities like rm, chgrp, chmod, and chown, even when symlinks are dereferenced. This mitigates accidental data loss, a frequent concern in administrative tasks, and aligns with best practices for secure operations without altering POSIX-required behaviors. Backup mechanisms, such as the --backup option with configurable methods (e.g., numbered or simple), further safeguard file integrity during modifications. Testing and validation processes for conformance rely on environmental controls and community-driven verification. Developers and users can validate POSIX compliance by setting POSIXLY_CORRECT or _POSIX2_VERSION and comparing outputs against standard expectations, with utilities providing consistent exit statuses (0 for success, nonzero for failure) as per POSIX. The project maintains an extensive test suite in its source repository, run during builds to catch deviations, and encourages bug reports with details like version, input, and expected versus actual output to the [email protected] mailing list for ongoing validation. This iterative process ensures alignment with evolving standards like POSIX.1-2008.

Commands

File Utilities

The file utilities in GNU Coreutils provide essential commands for managing files and directories at the filesystem level, enabling operations such as copying, moving, removing, and linking. These tools are designed for reliability and portability across Unix-like systems, with many fulfilling POSIX requirements for basic file handling. Among the core commands is cp, which copies files and directories while preserving attributes like permissions, timestamps, and ownership when specified with options such as -p or --preserve. It supports recursive copying via -r or -R for directory trees, making it suitable for duplicating entire structures, and includes interactive prompts (-i) to prevent accidental overwrites. Similarly, mv moves or renames files and directories by altering filesystem metadata, handling cross-device moves by copying and removing the original, and also supports interactive mode for safety. The rm command removes files or directories, with -r or --recursive enabling deletion of nonempty directories, and options like -i for prompting before each removal to avoid data loss; it operates on regular files, directories, and special files like device nodes. Directory-specific utilities include mkdir, which creates one or more directories with specified permissions using -m or --mode, and supports parent directory creation via -p to avoid errors if intermediates do not exist. Conversely, rmdir removes empty directories, failing if any contain files, and can operate recursively on multiple arguments. For linking, ln establishes hard links (default) or symbolic links (-s) between files, allowing shared data access without duplication, and handles relative or absolute paths for flexibility. The touch utility updates the access and modification timestamps of existing files or creates empty files if they do not exist, useful for signaling or placeholder creation with options like -t for custom dates. Finally, dd performs low-level data copying and conversion, reading from input blocks (e.g., files, devices) and writing to output with precise control over block sizes (bs=), skipping (skip=), and formats like ASCII-to-EBCDIC translation, making it ideal for disk imaging or data streaming. These commands handle special files, such as block or character devices, ensuring compatibility with diverse filesystem types. In system administration, these utilities are commonly used for tasks like backups—such as cp -r /source/dir /backup/ to mirror directories—or filesystem maintenance, including dd if=/dev/sda of=backup.img for creating disk images before hardware upgrades, and rm -rf /tmp/* (with caution) for clearing temporary files. Interactive and verbose options (-v) enhance usability in scripts and manual operations, reducing errors in production environments.

Text Utilities

The text utilities in GNU Coreutils provide essential tools for manipulating and processing textual data, enabling operations such as concatenation, sorting, extraction, and transformation of content from files or standard input. These utilities are designed for efficient handling of line-based text, supporting streaming output and integration into command-line pipelines for automated workflows. They form a foundational set for tasks involving data formatting and analysis, adhering to POSIX standards while offering GNU-specific enhancements for flexibility. The cat command concatenates files and copies their contents to standard output, facilitating the display or streaming of text for further processing. It supports binary file handling through options that detect and manage non-text data, such as --show-nonprinting to reveal control characters, making it suitable for inspecting mixed-content files. In applications like log processing, cat enables quick concatenation of multiple logs into a single stream, often piped to other tools for analysis. For example, cat log1.txt log2.txt merges the files seamlessly. Sorting and deduplication are handled by sort and uniq, which work in tandem to organize and refine text data. The sort utility orders lines based on custom keys, including numeric (-n), case-insensitive (-f), or locale-based comparisons (--locale=LOCALE), allowing adaptation to international character sets. It processes input streams efficiently, supporting field-specific sorting with delimiters like tabs or commas. Following sorting, uniq removes or reports duplicate adjacent lines, with options like -c to count occurrences and -i for case-insensitive matching; this requires prior sorting for comprehensive deduplication. These functions are critical in data analysis pipelines, such as cleaning datasets by sorting records numerically and eliminating repeats, as in sort -n -k1 file.txt | uniq. Extraction of portions or fields from text is achieved via head, tail, cut, and paste. The head and tail commands output the first or last parts of files, defaulting to 10 lines but customizable with -n NUM for lines or -c NUM for bytes; tail includes -f to follow growing files, ideal for real-time log monitoring. The cut utility extracts specific fields or characters using delimiters (-d DELIM) and field selectors (-f LIST), enabling precise parsing of structured text like CSV data. Complementing this, paste merges lines from multiple files side-by-side, with -d DELIM for custom separators and -s for serial pasting. In scripting pipelines, these tools support data sampling and reformatting, such as extracting columns from reports with cut -d',' -f1,3 data.csv | paste -s -d'\t' -. Character-level transformations are performed by tr, which translates, deletes, or squeezes characters, supporting operations like case conversion (tr 'a-z' 'A-Z') or removing duplicates (-s). It handles sets efficiently, including complements and ranges, and integrates with locales for Unicode support. The wc command counts newlines (-l), words (-w), and bytes (-c) in files, providing quick statistics for text volume assessment. These utilities excel in log processing and data analysis, where tr normalizes character encodings and wc gauges file sizes before intensive operations, often chained in scripts for automated text refinement.

Shell Utilities

The shell utilities in GNU Coreutils provide essential tools for managing the shell environment, formatting output, performing basic arithmetic, evaluating conditions, parsing paths, handling environment variables, and querying user and group information, enabling portable scripting in Bourne-compatible shells. These commands facilitate runtime interactions without relying on advanced shell features, ensuring compatibility across Unix-like systems. They are particularly valuable for constructing scripts that require conditional logic, variable manipulation, and standardized output, supporting POSIX standards where applicable while offering GNU-specific extensions for enhanced functionality. The date command displays the current date and time or sets the system date, using formats inspired by the C library's strftime function to produce human-readable or machine-parsable output, such as timestamps for logging in scripts. It supports options like --date for specifying relative or absolute times, making it indispensable for time-sensitive automation tasks in shell environments. For example, to reliably obtain the last day of the previous month in YYYY-MM-DD format, one can use date -d "last day of previous month" +%Y-%m-%d. An alternative mechanical syntax is date -d "$(date +%Y-%m-01) -1 day" +%Y-%m-%d. The first is simpler and direct, while the second is more explicit in its calculation. GNU extensions include nanosecond precision and locale-aware formatting, extending beyond basic POSIX requirements to handle complex date arithmetic portably. For output formatting, echo prints arguments to standard output, interpreting escape sequences like \n for newlines, while printf offers more precise control with format specifiers similar to the C printf function, supporting escaped printing of strings, numbers, and octal escapes for portability across shells lacking built-in formatting. These utilities are fundamental for generating formatted messages or data in scripts, with printf preferred for its consistency in avoiding trailing newlines and handling variable arguments reliably, as per POSIX guidelines. Arithmetic and string operations are handled by expr, which evaluates expressions involving integers, strings, and regular expressions, providing portable basic arithmetic (addition, subtraction, multiplication, division, modulus) without depending on shell-specific arithmetic expansions. It supports operations like string matching and length calculation, crucial for scripts in minimal shells, though it processes arguments as strings to maintain POSIX compatibility while offering GNU optimizations for efficiency. Conditional testing is enabled by test (also accessible as the [ builtin via a symlink), which evaluates logical expressions for file attributes, string comparisons, and numeric relations, forming the basis for if-then-else constructs in Bourne shell scripts. POSIX-compliant options include checks for file existence (-f), zero length (-z), and integer equality (-eq), with GNU extensions like =~ for regex matching enhancing script expressiveness without introducing non-portable features. Path parsing utilities basename and dirname extract the filename or directory portion from a pathname, respectively, stripping suffixes or extensions as needed for script logic involving file handling. These commands ensure portable path manipulation, avoiding assumptions about shell path expansion, and are POSIX-specified for use in constructing relative paths dynamically. Environment variable management is provided by env, which runs a command in a modified environment by setting, unsetting, or ignoring variables, and printenv, which displays the current environment or specific variables. These tools promote portability by allowing scripts to control inheritance without altering the global shell state, aligning with POSIX standards for printenv while env includes GNU options like -i for an empty environment. User and group information utilities include id, which prints the real and effective user and group IDs along with supplementary groups, and whoami, a simplified version that outputs only the effective user name. Both adhere to POSIX for id (with options like -u for UID) and support formatted output in id for scripting identity checks, such as verifying privileges in automated processes. Collectively, these shell utilities underpin robust, portable scripting by offering arithmetic, conditionals, and variable handling independent of shell builtins, reducing reliance on extensions in POSIX-minimal environments like traditional Bourne shells.

History and Development

Origins and Early Packages

The GNU Core Utilities originated within the broader GNU Project, launched by Richard Stallman on September 27, 1983, with the goal of creating a complete, free Unix-like operating system to promote software freedom and replace proprietary tools. As part of this initiative, the core utilities were developed in the late 1980s and early 1990s to provide open-source equivalents for essential Unix commands, enabling users to perform file management, text processing, and shell operations without relying on licensed software. These efforts emphasized portability and compatibility with emerging standards, motivated by the need for a self-sufficient free ecosystem that could run on various hardware. The initial packages emerged separately to address specific functionalities. Fileutils, the first such package, was announced and released as version 1.0 on February 8, 1990, by David MacKenzie, focusing on file operations like copying, moving, and listing files, implemented primarily in the C programming language. This release aligned with POSIX specifications from the outset to ensure broad usability across Unix-like systems. Shortly thereafter, in August 1991, MacKenzie released an updated Fileutils alongside the inaugural Textutils package, which included tools for text manipulation such as cat, cut, and sort, further expanding the suite of POSIX-compliant utilities. Shellutils followed in 1991, providing shell-related tools like basename, date, and who for process and environment management, also authored by MacKenzie and designed for integration with GNU's Bash shell. These early packages were maintained initially by MacKenzie, with Jim Meyering assuming primary maintenance responsibilities around that time to sustain development and ensure ongoing POSIX alignment. The separate structure allowed focused evolution, with versions like Fileutils 1.0 establishing a foundation for free software alternatives that prioritized reliability and extensibility over proprietary constraints.

Merger and Evolution

In September 2002, the GNU project began consolidating the separate Fileutils, Textutils, and Sh-utils packages into a unified Coreutils package to streamline maintenance, reduce redundancy, and facilitate coordinated development across the utilities. This effort culminated in the first major release, coreutils-5.0, on April 4, 2003, which integrated the final standalone versions: fileutils-4.1.11, textutils-2.1, and sh-utils-2.0.15. The merger eliminated the need for parallel updates across disparate packages, allowing developers to address common issues like portability and standards compliance more efficiently. Subsequent evolutions emphasized enhancing functionality while preserving compatibility with diverse Unix environments. Version 6.0, released on August 25, 2006, marked a significant milestone by introducing GNU-specific extensions, including new hashing utilities such as sha224sum, sha256sum, sha384sum, and sha512sum to support secure file integrity checks beyond traditional methods like MD5. This release also prioritized bug fixes, such as improved handling of file system boundaries in tools like ls and du, and portability enhancements to better accommodate variations in legacy Unix systems, including support for non-POSIX behaviors in older implementations. In July 2007, Coreutils underwent a key licensing evolution, shifting from GPL version 2 to GPL version 3 or later starting with version 6.10, to align with updated copyleft protections against emerging threats like hardware restrictions (Tivoization). This change, effective in the 6.10 release announced in early 2008, reflected broader GNU efforts to strengthen software freedoms amid growing feature complexity. Development during this period faced challenges in balancing an expanding utility set—now over 100 commands—with rigorous testing for legacy Unix variations, ensuring seamless operation across platforms from traditional BSD derivatives to emerging Linux distributions without breaking established scripts or behaviors.

Maintainers and Recent Releases

The GNU Coreutils package is currently maintained by a team of five primary developers: Jim Meyering, who has led maintenance since 1991; Paul Eggert; Pádraig Brady; Bernhard Voelker; and Collin Funk. Recent stable releases include version 9.7, announced on April 9, 2025, which incorporated 63 commits from 11 contributors over the prior 12 weeks, primarily addressing bug fixes and polishing existing functionality. Version 9.8 followed on September 22, 2025, introducing enhancements such as SHA-3 hashing support in the cksum utility and respect for cgroup v2 CPU quotas in the nproc utility, alongside various portability and performance improvements. The latest stable version, 9.9, was released on November 10, 2025, as a stabilization release with numerous bug fixes and performance improvements across tools like cp, sort, numfmt, and tail. Development occurs through a Git-based workflow hosted at git.sv.gnu.org/coreutils, where contributors submit patches via the [email protected] mailing list and releases are coordinated on the [email protected] discussion list, with announcements posted to the GNU Savannah news feed. The process emphasizes security hardening, such as mitigating buffer overflow vulnerabilities in utilities like cp and mv, and performance optimizations for modern hardware, including better I/O handling and reduced memory usage in file operations. Emerging trends in the Coreutils ecosystem include community discussions around rewriting components in Rust to enhance memory safety and prevent common C-based vulnerabilities like use-after-free errors, driven by growing adoption in distributions like Ubuntu. The uutils project, a cross-platform Rust reimplementation, released version 0.6.0 on February 2, 2026, achieving 96.28% compatibility with the GNU Coreutils test suite (622 out of 646 tests passing). This release removed unsafe code from utilities such as date and sort, replaced raw libc calls with safe alternatives, added ICU-based locale support for tools including date, sort, and join, included performance optimizations in multiple utilities, and improved platform support including Cygwin and RISC-V. Earlier progress included performance gains in select utilities such as faster factorization in factor and benchmarks for cksum, ongoing work on SELinux support, and adoption as the default coreutils in Ubuntu 25.10, though this has led to some compatibility breakage and ongoing fixes.

Licensing and Alternatives

Licensing

The GNU Core Utilities are licensed under the GNU General Public License version 3.0 or later (GPL-3.0-or-later). This copyleft license ensures that the software remains free and open source, granting users the rights to run, study, share, and modify the utilities while requiring any derivative works to be distributed under the same terms. Prior to version 6.10 released in 2007, the utilities were licensed under GPL-2.0-or-later. The upgrade to GPL-3.0-or-later aligned the project with the Free Software Foundation's (FSF) efforts to strengthen user freedoms, particularly by prohibiting "tivoization"—the practice of embedding free software in devices while using hardware or firmware restrictions to prevent users from running modified versions—and by providing explicit protections against software patents that could undermine the software's freedom. These changes addressed vulnerabilities in earlier GPL versions, ensuring that contributors implicitly grant patent licenses and that the software cannot be restricted in user-installable contexts. Under GPL-3.0-or-later, the utilities permit free redistribution in source or binary form, with the condition that recipients receive the corresponding source code or access to it. This fosters compatibility with other GPL-licensed software, enabling seamless integration in free operating systems while enforcing copyleft to prevent proprietary enclosures. Modifications are allowed, but any distributed changes must preserve the same freedoms for downstream users. The accompanying documentation, including user manuals, is licensed separately under the GNU Free Documentation License version 1.3 or later (FDL-1.3-or-later), which allows copying, distribution, and modification of the manuals while requiring attribution and the inclusion of any invariant sections if present (none in this case). Source code for the utilities is publicly available via the official GNU FTP servers and the project's Savannah repository, facilitating verification, auditing, and contributions.

Alternative Implementations

BusyBox provides a lightweight, single-binary implementation of core Unix utilities designed primarily for embedded systems and resource-constrained environments. It combines minimalist versions of many common tools into one executable, offering replacements for most utilities found in GNU coreutils while omitting some advanced features to prioritize size and simplicity. Licensed under GPL-2.0-only, BusyBox is widely adopted in scenarios like routers and IoT devices where minimal footprint is essential. uutils, also known as Rust Coreutils, is a memory-safe rewrite of core utilities in the Rust programming language, licensed under the MIT License, emphasizing security and cross-platform compatibility for modern production environments. Its latest release, version 0.6.0 released on February 2, 2026, achieves 96.28% compatibility with the GNU coreutils test suite (622 out of 646 tests passed), with key improvements including the removal of unsafe code from utilities such as date and sort, replacement of raw libc calls with safe nix crate equivalents, ICU integration for enhanced locale support in date, sort, and join, performance optimizations in tools including base64, shuf, uniq, and df, and improved platform support including Cygwin and RISC-V. Ubuntu integrated uutils as the default coreutils implementation in version 25.10, marking a shift toward Rust-based tools in mainstream distributions; however, the integration has uncovered some bugs, such as issues with the date and du commands, which are being addressed through ongoing upstream development. Toybox serves as a POSIX-focused alternative, combining command-line utilities into a single BSD-licensed executable to promote minimalism and standards compliance. It was merged into the Android Open Source Project in 2015 as a replacement for the older toolbox, enabling self-hosting builds and supporting POSIX-2008 and LSB 4.1 specifications. Toybox prioritizes a small codebase for environments like mobile systems, providing essential functionality without the extensiveness of full-featured suites. These implementations trade off against GNU coreutils in key areas: BusyBox excels in binary size, often under 1 MB for its multicall executable compared to several MB for GNU's separate binaries, making it ideal for embedded use but with reduced feature completeness. uutils enhances safety by leveraging Rust's memory safety guarantees, avoiding common C-based vulnerabilities present in GNU and BusyBox, though its binaries are moderately larger due to Rust's overhead. Toybox balances minimalism and POSIX adherence similarly to BusyBox but with a public-domain-friendly license, achieving high standards compliance while covering core essentials for Android without GNU's full richness. Overall, GNU coreutils remains the most complete and feature-rich option for general-purpose systems.

References

  1. https://www.gnu.org/s/coreutils/
  2. https://www.gnu.org/software/coreutils/
  3. https://www.gnu.org/software/fileutils/
  4. https://www.gnu.org/
  5. https://savannah.gnu.org/projects/coreutils
  6. https://www.gnu.org/s/coreutils/manual/coreutils.html
  7. https://lists.gnu.org/archive/html/info-gnu/2025-11/msg00000.html
  8. https://opensource.com/article/18/4/gnu-core-utilities
  9. https://www.gnu.org/software/coreutils/manual/coreutils.html
  10. https://savannah.gnu.org/news/?id=10827
  11. https://www.linuxfromscratch.org/lfs/view/development/chapter08/coreutils.html
  12. https://wiki.gentoo.org/wiki/GNU_Coreutils
  13. https://www.gnu.org/software/coreutils/manual/html_node/Standards-conformance.html
  14. https://www.gnu.org/software/coreutils/manual/html_node/Treating-_002f-specially.html
  15. https://www.gnu.org/software/coreutils/manual/coreutils.html#cat-invocation
  16. https://www.gnu.org/software/coreutils/manual/coreutils.html#sort-invocation
  17. https://www.gnu.org/software/coreutils/manual/coreutils.html#uniq-invocation
  18. https://www.gnu.org/software/coreutils/manual/coreutils.html#head-invocation
  19. https://www.gnu.org/software/coreutils/manual/coreutils.html#tail-invocation
  20. https://www.gnu.org/software/coreutils/manual/coreutils.html#cut-invocation
  21. https://www.gnu.org/software/coreutils/manual/coreutils.html#paste-invocation
  22. https://www.gnu.org/software/coreutils/manual/coreutils.html#tr-invocation
  23. https://www.gnu.org/software/coreutils/manual/coreutils.html#wc-invocation
  24. https://www.gnu.org/software/coreutils/manual/html_node/Introduction.html
  25. https://lists.gnu.org/archive/html/info-gnu/2003-04/msg00000.html
  26. https://lists.gnu.org/archive/html/info-gnu/2006-08/msg00021.html
  27. https://www.gnu.org/licenses/gpl-3.0.en.html
  28. https://git.savannah.gnu.org/cgit/coreutils.git/tree/NEWS
  29. https://www.gnu.org/people/people.en.html
  30. https://lists.gnu.org/archive/html/info-gnu/2025-04/msg00006.html
  31. https://savannah.gnu.org/forum/forum.php?forum_id=6662
  32. https://www.phoronix.com/news/GNU-Coreutils-9.8
  33. https://git.savannah.gnu.org/cgit/coreutils.git/log/
  34. https://uutils.github.io/blog/2025-02-extending/
  35. https://github.com/uutils/coreutils/releases/tag/0.6.0
  36. https://www.phoronix.com/news/Rust-Coreutils-0.6
  37. https://github.com/uutils/coreutils/releases/tag/0.4.0
  38. https://github.com/uutils/coreutils/wiki/Supporting-SELinux-in-the-coreutils
  39. https://discourse.ubuntu.com/t/migration-to-rust-coreutils-in-25-10/59708
  40. https://www.gnu.org/licenses/gpl-3.0.html
  41. https://bugs.gentoo.org/207345
  42. https://www.gnu.org/licenses/rms-why-gplv3.en.html
  43. https://www.embeddedrelated.com/showarticle/1639.php
  44. https://www.commandlinux.com/man-page/man1/busybox.1.html
  45. https://busybox.net/
  46. https://github.com/uutils/coreutils
  47. https://discourse.ubuntu.com/t/carefully-but-purposefully-oxidising-ubuntu/56995
  48. https://lwn.net/Articles/1043103/
  49. https://ostechnix.com/rust-uutils-du-command-wrong-size-ubuntu-25-10/
  50. https://landley.net/toybox/
  51. https://lwn.net/Articles/629362/
  52. https://github.com/landley/toybox
  53. https://unix.stackexchange.com/questions/6182/any-options-to-replace-gnu-coreutils-on-linux
  54. https://linuxsecurity.com/news/vendors-products/rust-takes-the-stage-in-ubuntu-with-coreutils-overhaul
  55. https://machaddr.substack.com/p/comparing-coreutils-its-rust-based
Add your contribution
Related Hubs
User Avatar
No comments yet.