Ubuntu 26.10 is completing its move to Rust-based core utilities. Development builds now use the uutils implementations of cp, mv and rm, the three important commands that Ubuntu 26.04 LTS deliberately kept on GNU Coreutils. For most desktop users the change should be invisible, but administrators and developers should test scripts that depend on exact GNU behaviour before using Ubuntu 26.10 in production.
Key takeaways
- Ubuntu 26.10 is still a development release and is expected in October 2026.
- The default core utilities are now entirely supplied by the Rust-based
uutilsproject, includingcp,mvandrm. - Ubuntu 26.04 LTS kept GNU versions of those three commands because unresolved file-operation issues required more work.
- Most normal commands should behave the same, but complete GNU compatibility is still a work in progress upstream.
- GNU Coreutils remains available as a fallback; users should not switch providers casually on an important system.
What changed in Ubuntu 26.10?
Ubuntu has been replacing the traditional GNU Coreutils package with uutils Coreutils, a cross-platform reimplementation written in Rust. Coreutils supplies many familiar commands used every day on Linux, including ls, cat, chmod, date, sort, cp, mv and rm.
The transition was intentionally gradual. Ubuntu made Rust Coreutils the default provider earlier, but the Ubuntu 26.04 LTS implementation continued using the GNU versions of cp, mv and rm. The current official Ubuntu 26.10 release notes now say that those remaining utilities have migrated, making the default set fully Rust-based.
| Ubuntu release | Default Coreutils position | cp, mv and rm |
Status |
|---|---|---|---|
| Ubuntu 26.04 LTS | Mostly Rust-based uutils | GNU implementations retained | Supported LTS release |
| Ubuntu 26.10 | Entire default set supplied by uutils | Rust implementations | In development; not yet a production release |
This is a change to the default implementation, not a redesign of the command line. A user still types cp report.txt backup/, and scripts still call commands such as mv and rm by their normal names.
Why were cp, mv and rm delayed?
Copying, moving and deleting files are unusually sensitive operations. A small compatibility error can do more damage than a formatting difference in a command such as printf. Canonical therefore held these utilities back while the remaining problems were investigated and corrected.
In its April engineering update, Canonical said an independent security audit and internal review found numerous issues across uutils. Most were fixed, but eight open time-of-check to time-of-use concerns remained around cp, mv and rm. That was why the Ubuntu 26.04 implementation retained the GNU commands rather than forcing a complete transition into an LTS release.
A time-of-check to time-of-use race can occur when software checks a file or path and the underlying filesystem state changes before the operation completes. Symlinks, recursive directory traversal, permissions and replacement operations make this especially important for file-management tools.
The upstream project continued improving safe recursive operations, race handling and GNU compatibility. Its release notes describe substantial security hardening and a growing number of passing tests from the GNU test suite. That progress helps explain why Ubuntu is now comfortable moving the remaining utilities in its interim development release. It does not mean the Rust and GNU implementations are proven identical in every edge case.
What is uutils Coreutils?
uutils is an open-source effort to reproduce GNU Coreutils in Rust while supporting Linux and other operating systems. The project’s stated goal is to match GNU output and exit behaviour closely enough to act as a drop-in replacement. Differences are treated as bugs, but the project also clearly warns that some options or behaviours can still differ.
| Area | GNU Coreutils | uutils Coreutils |
|---|---|---|
| Primary implementation | C | Rust |
| Linux history | Mature and widely deployed for decades | Newer replacement tested across multiple platforms |
| Compatibility target | Reference behaviour for GNU systems | Aims to match GNU output, options and exit codes |
| Main attraction | Established compatibility and predictability | Memory-safety benefits, portability and modern development tooling |
| Main concern | Legacy C code can contain memory-safety defects | Remaining behavioural differences and a shorter deployment history |
Rust prevents several classes of memory errors at compile time, but the language alone cannot prevent every filesystem race, logic error or compatibility regression. The safer conclusion is that Rust reduces some risks while testing, review and careful integration remain necessary.
Will Ubuntu 26.10 break existing shell scripts?
Most ordinary shell scripts should continue working because the command names and common options remain the same. The greatest risk is not a simple command such as cp file.txt /tmp/. It is automation that depends on a rarely used GNU option, exact error wording, a particular exit code, unusual symlink behaviour or an edge case involving permissions and filesystems. Our explanation of the Linux ln command and symbolic links provides useful background for testing those link-related cases.
Administrators should pay closer attention to backup jobs, deployment scripts, package-building environments, container image builds and recovery automation. These workflows can make assumptions that are invisible until an error path is triggered.
| Check | Why it matters | Recommended test |
|---|---|---|
| Command options | A less common GNU flag may behave differently | Run the real script against representative files in a disposable VM |
| Exit codes | Automation may branch on a precise status | Test both successful and deliberately failing operations |
| Symlinks | Recursive copy and replacement behaviour can be sensitive | Include links, broken links and links crossing directory boundaries |
| Permissions and ownership | Backups and deployments often preserve metadata | Verify modes, owners, timestamps, ACLs and extended attributes |
| Error output | Some scripts incorrectly parse human-readable messages | Prefer exit codes; identify any workflow that parses stderr text |
Our guide to creating shell scripts in Linux covers the basic structure of scripts. For this transition, the important improvement is to test failure cases as carefully as successful ones.
How can you check which Coreutils implementation is running?
On an Ubuntu test system, start by asking an individual command for its version:
cp --version | head -n 1
mv --version | head -n 1
rm --version | head -n 1GNU tools normally identify themselves as GNU Coreutils. A uutils command reports its own Coreutils version. You can also inspect the installed provider packages without changing the system:
apt-cache policy coreutils-from-uutils coreutils-from-gnu rust-coreutils
dpkg -l | grep -E 'coreutils|rust-coreutils'Do not rely only on the Ubuntu version number. Development images change frequently, and an upgraded or manually modified system may use a different provider from a clean installation.
Can Ubuntu users switch back to GNU Coreutils?
Yes. Ubuntu continues packaging a GNU provider. The official Ubuntu documentation gives the following provider-switch command:
sudo apt install coreutils-from-gnu --allow-remove-essentialThe --allow-remove-essential option is a serious warning, not decoration. Core utilities are fundamental system packages. Do not experiment with provider changes on a remote production server without a tested backup, console access and a recovery plan.
To return to the Rust provider, Ubuntu documents:
sudo apt install coreutils-from-uutils --allow-remove-essentialMost users should leave the distribution default unchanged. The fallback is valuable when a confirmed compatibility problem blocks a specific workload, not as a routine post-installation tweak.
Should you install Ubuntu 26.10 now for Rust Coreutils?
No, not on an important machine. Ubuntu 26.10 is still under development. Its release notes, packages and default configuration can continue changing before the final October release. A development image is appropriate for testing the transition, reporting regressions and checking important automation in advance.
Ubuntu 26.04 LTS users do not need to move to an interim release simply to obtain a newer Coreutils implementation. LTS users should prioritize stability and supported updates. If you test Ubuntu 26.10, use a virtual machine or spare system and keep copies of any files used for destructive command tests.
The distribution is also targeting the newer Linux 7.3 kernel. Our Linux 7.3 release-candidate overview explains why that kernel is still testing software rather than an automatic recommendation for existing Ubuntu installations.
LinuxPanda assessment: a sensible milestone, not the end of GNU
Completing the default uutils transition is meaningful because cp, mv and rm sit at the foundation of desktop use, server administration and software builds. Ubuntu’s decision to delay them in 26.04 and introduce them through the following interim release is more reassuring than pretending the earlier concerns never existed.
The change should not be described as Ubuntu removing GNU software or proving that Rust automatically makes every command safe. GNU Coreutils remains available, and compatibility is something measured through real workloads—not assumed from the implementation language.
The practical opportunity comes before Ubuntu 26.10 reaches stable: teams can run their installation, backup and deployment scripts against current development images, report reproducible differences and avoid discovering an edge case during a later production upgrade. Linux users who do not maintain automation can simply wait for the final release and allow Ubuntu’s normal update path to handle the default.
Common questions
Is Ubuntu 26.10 replacing every GNU command with Rust?
No. This change concerns the Coreutils collection, not every GNU component in Ubuntu. Bash, GCC, glibc and many other packages are separate projects.
Are cp, mv and rm commands changing their names?
No. Users continue typing the familiar command names. The implementation providing those commands changes from GNU Coreutils to uutils by default.
Is Rust Coreutils completely compatible with GNU Coreutils?
Not perfectly in every edge case. The uutils project aims for GNU compatibility and continues reducing test failures, but its own documentation acknowledges that some options or behaviours may differ.
Will Ubuntu 26.04 LTS receive the same complete transition?
The current Ubuntu 26.04 documentation still describes cp, mv and rm as GNU-provided exceptions. Users should follow supported Ubuntu updates rather than assuming that a development-release decision has automatically been backported to the LTS.
Should server administrators switch back to GNU immediately?
No. Test existing automation first. Switch providers only when a confirmed compatibility problem justifies the change and you have a safe recovery path.
Comments