## 1. Project Overview & Quickstart (uutils/installation) # installation Open-source repository uutils/installation ### Repository Details - **Repository:** [uutils/installation](https://github.com/uutils/installation) - **Primary Language:** Code *Note: High-volume repository documentation is actively indexed and synchronized by YakaAI.* ## 2. Official Technical Reference & Guides (uutils/uutils.github.io) ## File: README.md # coreutils documentations This repository generates the user and dev documentations of https://github.com/uutils/coreutils ## User documentation It is available on: https://uutils.org/coreutils/docs/ Can be generated with: ```bash cargo run --bin uudoc --all-features cd docs mdbook build ``` ## Playground An in-browser playground runs the uutils coreutils WASM build directly in your browser: https://uutils.org/playground/ See also how it works: https://uutils.org/playground-how-it-works/ ## Developer documentation: It is available on: https://uutils.org/dev/coreutils/ Can be generated with: ```bash cargo doc --no-deps --all-features --workspace ``` The website CI builds this on each `main`/scheduled run and publishes it under `/dev/coreutils/` (and `/dev/findutils/`) as part of the deploy. ## Build timing Generated by cargo, the build timings can be seen on: https://uutils.org/cargo-timings/cargo-timing.html --- ## File: content/blog/_index.md +++ template = "section.html" sort_by = "date" page_template = "post.html" title = "Blog" +++ You can subscribe to this blog with this [atom feed](/atom.xml). --- ## File: content/blog/2025-02-extending.md +++ title = "Extending the Coreutils project - Rewriting base tools in Rust" date = 2025-02-01 page_template = "post.html" authors = ["Sylvestre Ledru"] +++ As I [just presented at FOSDEM](https://sylvestre.ledru.info/coreutils-fosdem-2025/), we are moving into the next phase of the uutils project. Over the last five years, we have been working on reimplementing some of the key Linux tools in Rust. We started with the [Coreutils](https://github.com/uutils/coreutils) and [findutils](https://github.com/uutils/findutils). As we approach feature parity with the GNU Coreutils implementation, and as its adoption in production environments continues to expand, we have been thinking about what is next. Given the very positive feedback around this initiative, we are going to extend our efforts to rewrite other parts of the modern Linux/Unix/Mac stack in Rust (still with Windows support in mind when relevant). These efforts will be managed under the [uutils umbrella](https://github.com/uutils/), which will allow us to maintain a cohesive and unified approach across various utilities. We also noticed a lot of contributions on these projects coming from a diverse group of hackers (530 different contributors on Coreutils alone!). With the growing enthusiasm for Rust and the eagerness to learn it, now is the best time to push this project forward. Rewriting in Rust will help with the long-term maintenance of the ecosystem, ensuring it stays robust, safe, and welcoming for new generations of contributors. ### Vision for the Future As we expand the scope of the project, we are working on a future where Rust becomes the backbone of essential Linux, Unix, and potentially macOS system tools. Our focus will be on improving security, ensuring long-term maintainability, and optimizing performance for both modern and legacy systems. Through the uutils umbrella, we aim to create a more secure, efficient, and scalable alternative to the traditional tools, replacing software developed in older, less secure programming languages like C. This project is also an investment for the future. C is becoming less popular with the next generation of developers. Just like how the Linux kernel continues to evolve and includes Rust, it is our responsibility to upgrade the core utilities of the system to a modern, safer programming language. By doing so, we ensure that the essential tools used in Linux/Unix systems remain relevant, maintainable, and accessible to future contributors. ### Specific Benefits of Rust Rust offers several advantages over C/C++, particularly in terms of memory safety, concurrency, and performance. By eliminating common security issues such as null pointer dereferences and buffer overflows, Rust allows us to build tools that are inherently safer. Its modern compiler tooling also enables us to optimize performance without sacrificing code safety, ensuring that our utilities can handle the demands of modern computing environments while remaining easy to maintain. ### Challenges and Opportunities As with any large-scale reimplementation, there are challenges to overcome. Porting complex utilities from C to Rust requires careful consideration of edge cases and platform-specific behaviors. Additionally, ensuring full compatibility across Linux, Unix, and macOS environments presents unique challenges. However, these challenges also offer opportunities for growth and innovation, allowing us to extend and refine core system utilities for modern needs. Rust's modern design gives us the chance to improve both security and performance while maintaining cross-platform compatibility. ### Next Steps For the next phase of the project, we are adopting the same approach: a drop-in replacement of the C implementations. Here's what's coming next: | Name | Description | Status | |----------------------------------------------------|----------------------------------------------------|-----------------------------| | [acl](https://github.com/uutils/acl) | Access control list utilities | | | [bsdutils](https://github.com/uutils/bsdutils) | Basic utilities for BSD compatibility | | | [coreutils](https://github.com/uutils/coreutils) | Basic utilities for the system | Production level | | [diffutils](https://github.com/uutils/diffutils) | File comparison utilities | Almost ready | | [findutils](https://github.com/uutils/findutils) | Utilities for finding files | Getting close to completion | | [hostname](https://github.com/uutils/hostname) | Utility to show or set system hostname | | | [login](https://github.com/uutils/login) | User login management utilities | | | [procps](https://github.com/uutils/procps) | Utilities for monitoring and controlling processes | | | [util-linux](https://github.com/uutils/util-linux) | Utilities essential for Linux systems | | These packages are part of the essential list for Debian and Ubuntu, and we're excited to push their Rust reimplementation further. ### GSoC 2024 Participation In 2024, we had the pleasure of mentoring three students during Google Summer of Code (GSoC): 1. **Sreehari Prasad** worked on improving the support of Rust CCoreutils. His focus was on making uutils compatible with the GNU coreutils test suite. Sreehari resolved most of the failing tests for the `cp`, `mv`, and `ls` utilities and significantly enhanced compatibility. 2. **Hanbings** tackled the implementation of key GNU `findutils` utilities like `xargs` and `find` in Rust. His work focused on improving compatibility with the GNU suite while enhancing performance, resulting in major progress on missing features and test code. 3. **Krysztal Huang** worked on implementing the `procps` suite, which includes utilities like `slabtop`, `top`, `pgrep`, `pidof`, `ps`, `pidwait`, and `snice`. This project involved implementing some of these commands. ### Call to Action for Contributors Contributors who are passionate about system-level programming and Rust are always welcome. Whether you're experienced with GNU utilities or just learning Rust, your contributions will be invaluable to this project. You can get involved by picking up good-first issues, reviewing code, or even helping us test new features across various platforms. The [uutils GitHub organization](https://github.com/uutils) has all the information you need to get started. You can also sponsor the project through [GitHub Sponsors](https://github.com/sponsors/uutils). ### FAQ **How long is it going to take?** Some programs, like `diff`, `acl`, or `hostname`, could be completed quickly, while others will take years to finish. **Do you hate the GNU project?** Not at all. We often contribute to the upstream implementations when we identify issues, add missing tests, and so on. **Why the MIT License?** For consistency purposes. We're not interested in a license debate and will continue to use the MIT license, as we did with Coreutils. **The binaries are too big. Does it really matter?** Yes, Rust binaries are generally bigger than GNU's, but we don't think it's a blocker, even for embedded devices. **Is it really safer?** While Rust is better than C/C++ for security, these programs are often already very safe. Security is not the key argument for us in this rewrite even if Rust provides some automatic improvements. **What about performance?** Although we haven't started optimizing yet, Rust's design facilitates performance improvements naturally. We are confident that, in time, these tools will match or exceed the performance of their GNU counterparts. --- ## File: content/blog/2025-04-playground.md +++ title = "Try Uutils Coreutils directly in your browser" date = 2025-04-04 page_template = "post.html" authors = ["Sylvestre Ledru"] +++ We are happy to announce the [Uutils playground](/playground) - an interactive terminal that lets you run real Rust Uutils Coreutils directly in your browser, with no installation, no server, and no network round-trips after the initial page load. Just open the page and start typing commands like `ls`, `sort`, `cat`, `head`, `factor`, or any of the 60+ utilities available. You can pipe commands together (`sort fruits.txt | uniq -c | sort -rn`), use redirections (`echo hello > file.txt`, `cat < file.txt`), explore the virtual filesystem, and even switch between 30+ languages using the locale dropdown. ### How it works The Uutils Coreutils are compiled to WebAssembly (targeting `wasm32-wasip1`) as a single multicall binary - similar to BusyBox. When you type a command, a minimal JavaScript shell parses your input, sets up pipes between stages, and executes each one by instantiating the WASM binary with the right arguments. A virtual in-memory filesystem backed by [browser_wasi_shim](https://github.com/bjorn3/browser_wasi_shim) provides file I/O. Everything runs client-side - once loaded, the playground works entirely offline. An important distinction worth noting: **coreutils only provides individual commands** (`sort`, `cat`, `ls`, etc.). Features like `if`/`then`/`else`, `while` loops, variable expansion (`$VAR`), and globbing (`*.txt`) are shell features provided by Bash, Zsh, or similar - not by coreutils. The playground's JavaScript shell is intentionally minimal, keeping the focus on the coreutils themselves. For a deeper look at the architecture - including diagrams, the multicall dispatch mechanism, the `feat_wasm` feature gate, and how localization is handled - check out the [full technical deep-dive](/playground-how-it-works). ### Try it, break it, improve it Give the [playground](/playground) a spin and let us know what you think! Contributions are welcome - whether it is improving WASI compatibility to enable more commands, adding translations via [Weblate](https://hosted.weblate.org/projects/rust-coreutils/), or enhancing the playground shell itself. --- ## File: content/blog/test.md +++ title = "Test post" draft = true date = 2024-01-31 authors = ["Terts Diepraam"] +++ This is a test post # Heading 1 --- ## File: content/_index.md +++ title = "Home" template = "index.html" +++ uutils --about user@machine:~$ uutils --about uutils_ Cross-platform Rust reimplementations of the command-line tools you use every day, with full GNU compatibility. Try the playground View on GitHub The uutils project reimplements ubiquitous command line utilities in Rust. Our goal is to modernize the utils, while retaining full compatibility with the existing utilities. We are planning to replace all essential Linux tools. # Why? C has served us well for decades, but it is time to move on. For new generations of developers, Rust is more appealing — and it brings real, substantive benefits: - **Memory safety** — eliminates entire categories of bugs without sacrificing performance - **Cross-platform portability** — the same code runs on Linux, macOS, Windows, Android, FreeBSD, NetBSD, OpenBSD, Solaris, Illumos, Fuchsia, Redox and even [WebAssembly](/playground) - **Modern tooling** — Cargo, crates.io and a rich ecosystem mean we don't have to reinvent the wheel - **Easy parallelism** — fearless concurrency built into the language - **Terrific performance** — on par with or better than C implementations - **Modern engineering practices** — excellent CI coverage (build on many OS/archs, GNU test suite execution), a smooth contributor experience, and continuous fuzzing (including differential fuzzing) at the review phase to catch edge cases early This is not about fighting the GNU project. It is not primarily about security (GNU coreutils only had [17 CVEs since 2003](https://security-tracker.debian.org/tracker/source-package/coreutils)) or about license debates. It is about **modernizing foundational software** so it can be maintained and improved by the next generation of contributors. Ubuntu is already [carefully but purposefully adopting](https://discourse.ubuntu.com/t/carefully-but-purposefully-oxidising-ubuntu/56995) uutils coreutils, Debian might follow the same path, and Microsoft offers it as well. # Projects uutils list --status $ uutils list --status coreutilseveryday commands: `ls`, `cp`, `mv`ready findutils`find`, `locate`, `xargs`beta diffutils`diff`, `cmp`, `diff3`, `sdiff`beta grep`grep`, `egrep`, `fgrep`beta shadow`useradd`, `passwd`, `groupadd`beta util-linux`mount`, `fdisk`, `lsblk`, `dmesg`in progress procps`ps`, `top`, `free`, `vmstat`in progress sedstream editor for filtering and transforming textalpha awkpattern scanning and text-processing languagein progress tarcreate and extract tar archivesin progress acl`getfacl`, `setfacl`, `chacl`in progress hostnameshow or set the system hostnamein progress login`login`, `su`, `passwd`in progress bsdutils`cal`, `logger`, `script`, `wall`in progress # Crates We maintain a variety of public crates to support our projects, which are published on [crates.io](https://crates.io/). - [`ansi-width`](https://github.com/uutils/ansi-width) - [`num-prime`](https://github.com/uutils/num-prime) - [`parse_datetime`](https://github.com/uutils/parse_datetime) - [`platform-info`](https://github.com/uutils/platform-info) - [`uutils-term-grid`](https://github.com/uutils/uutils-term-grid) # Who we are uutils is a community-driven, open-source effort maintained by volunteers around the world. There is no company behind it, just contributors who care about the future of foundational command-line tools. Everything happens in the open on [GitHub](https://github.com/uutils), and newcomers are genuinely welcome. Many of our contributors landed their first-ever open-source patch on a uutils project, and we are happy to help you do the same. [Meet the team](/team) behind uutils. # Contributing You can help us out by: - [Tackling a good first issue](https://github.com/search?q=org%3Auutils+is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22&type=issues&s=created&o=desc) across any of our projects (the easiest way to get started) - Contributing code - Contributing documentation - Reporting bugs (e.g. incompatibilities with GNU utilities) - Triaging bugs - [Sponsoring uutils on GitHub](https://github.com/sponsors/uutils) You can join our [Discord server](https://discord.gg/wQVJbvJ) to discuss or ask anything concerning uutils. We're happy to help you get started with contributing! # Talks & Media We did a few talks about this project, see [our talks & media page](/talks). # Friends of uutils We collaborate with and build upon many other projects in the Rust community, either by using or providing crates. We highly recommend giving these projects a look! - [`nushell`](https://www.nushell.sh/) - [`ripgrep`](https://github.com/burntsushi/ripgrep) - [`eza`](https://github.com/eza-community/eza) --- ## File: content/acl.md +++ title = "acl" template = "project.html" [extra] wip = true +++ uutils acl is a work-in-progress Rust reimplementation of the acl utilities, which are used to manage POSIX Access Control Lists. This project aims to provide memory-safe replacements for tools such as `getfacl` and `setfacl`. > **Note:** This project is still in early development. Many features are not yet implemented and behavior may differ from the original acl tools. # Goals Implement a memory-safe set of ACL utilities compatible with the original command-line interfaces. # Contributing To contribute to uutils acl, please see [CONTRIBUTING](https://github.com/uutils/acl/blob/main/CONTRIBUTING.md). # License uutils acl is licensed under the MIT License - see the [LICENSE](https://github.com/uutils/acl/blob/main/LICENSE) file for details. The acl package is licensed under the GPL 2.0 or later. --- ## File: content/awk.md +++ title = "awk" template = "project.html" [extra] wip = true +++ Rust implementation of `awk`, the pattern scanning and text-processing language. This project aims to be a drop-in replacement of the original command. # Goals This project aims to be a drop-in replacement for GNU awk (gawk). Differences with the original are treated as bugs. # Contributing To contribute to uutils awk, please see [CONTRIBUTING](https://github.com/uutils/coreutils/blob/main/CONTRIBUTING.md). # License uutils awk is licensed under the MIT License or the Apache License 2.0, at your option - see the [LICENSE-MIT](https://github.com/uutils/awk/blob/main/LICENSE-MIT), [LICENSE-APACHE](https://github.com/uutils/awk/blob/main/LICENSE-APACHE) file for details. --- ## File: content/bsdutils.md +++ title = "bsdutils" template = "project.html" [extra] wip = true +++ uutils bsdutils is a work-in-progress Rust reimplementation of the BSD utilities, a collection of standard Unix tools originating from BSD systems. > **Note:** This project is still in early development. Many features are not yet implemented. # Goals Implement a cross-platform, memory-safe set of BSD utilities compatible with their original command-line interfaces. # Contributing To contribute to uutils bsdutils, please see [CONTRIBUTING](https://github.com/uutils/bsdutils/blob/main/CONTRIBUTING.md). # License uutils bsdutils is licensed under the MIT License - see the [LICENSE](https://github.com/uutils/bsdutils/blob/main/LICENSE) file for details. --- ## File: content/coreutils.md +++ title = "coreutils" template = "project.html" [extra] status = "ready" +++ uutils coreutils is a cross-platform reimplementation of the GNU coreutils in Rust. While all programs have been implemented, some options might be missing or different behavior might be experienced. [](https://github.com/uutils/coreutils-tracking) # Goals This project aims to be a drop-in replacement for the GNU utils. Differences with GNU are treated as bugs. uutils aims to work on as many platforms as possible, to be able to use the same utils on Linux, Mac, Windows and other platforms. This ensures, for example, that scripts can be easily transferred between platforms. # Contributing To contribute to uutils coreutils, please see [CONTRIBUTING](https://github.com/uutils/coreutils/blob/main/CONTRIBUTING.md). # License uutils coreutils is licensed under the MIT License - see the [LICENSE](https://github.com/uutils/coreutils/blob/main/LICENSE) file for details. GNU Coreutils is licensed under the GPL 3.0 or later.