Microsoft is shipping Linux's core commands on Windows, built in Rust

Microsoft is putting Linux’s everyday commands on Windows, and it built them in Rust. At its Build 2026 conference on June 2, the company announced Coreutils for Windows, a set of native ls, cp, grep, and friends that install with one winget command. No WSL, no Linux VM. The commands just run.

That sounds like a convenience feature, and for most developers it is. But the interesting part isn’t the commands. It’s where they came from: not GNU’s decades-old C code, but uutils, a community rewrite of coreutils in Rust under a permissive license. Microsoft didn’t port the originals. It picked a different lineage entirely, and that choice says a lot about how the company thinks about open source in 2026.

What Coreutils for Windows actually is

Coreutils is the unglamorous plumbing of any Linux system. When you type ls to list a folder, cp to copy a file, or cat to print one, you’re running coreutils. There are dozens of these tools, and Linux developers reach for them hundreds of times a day without thinking about it.

On Windows, those muscle-memory commands don’t exist by default. You get dir instead of ls, copy instead of cp, and no grep at all. Developers who bounce between a Mac laptop, a Linux server, and a Windows desktop hit that wall constantly. Microsoft’s own framing is blunt: “Developers constantly move between platforms, but familiar commands don’t work consistently, forcing workarounds, lost speed and context switching,” the company told BleepingComputer.

Coreutils for Windows closes that gap. You run winget install Microsoft.Coreutils and you get a working ls, cp, mv, find, and more, behaving the way they do everywhere else. The first release covers 14 commands, including cat, grep, pwd, rm, tee, and base64. Microsoft deliberately skipped a few: tools that collide with Windows built-ins (dir, more, whoami) and ones that need POSIX features Windows doesn’t have (chmod, chown, kill, timeout).

There’s a neat implementation trick under the hood. Rather than ship 14 separate executables, Microsoft bundles everything into a single coreutils.exe. The installer then creates NTFS hardlinks for each command, all pointing back at that one binary, and the program figures out which utility to run based on the name you typed. It’s the same multi-call pattern BusyBox has used on Linux for years, which is a small tell that the people who built this know the territory.

Why building on Rust matters

Here’s the load-bearing detail. The original GNU coreutils is written in C and licensed under the GPLv3. Microsoft’s package isn’t based on that code at all. It’s built on uutils, a cross-platform rewrite of GNU coreutils in Rust that the community has been grinding on for years, bundled with a findutils port and a GNU-compatible grep.

Two things flow from that choice, and both are the actual story.

The first is memory safety. C is fast and everywhere, but it lets you read past the end of a buffer, use memory after you’ve freed it, and dereference null pointers, the bug classes behind a large share of security vulnerabilities. Rust’s compiler rejects most of those at build time without a garbage collector slowing things down. For tools that parse untrusted filenames and pipe data around all day, that’s a real reduction in attack surface, not a marketing line.

The second is the license, and it’s the quietest, most consequential part of the whole announcement. GNU coreutils ships under the GPLv3, a strong copyleft license: if you distribute a modified version, you have to release your changes under the same terms. uutils is licensed under the permissive MIT license, which has no such requirement. A company can take MIT code, bundle it into a closed product, and ship it without copyleft strings attached.

That distinction is why uutils exists in the form it does, and it hasn’t been quiet on the Linux side. When Canonical announced plans to swap GNU coreutils for the Rust version in Ubuntu 25.10, part of the free-software community pushed back hard, arguing that replacing GPL tools with MIT-licensed ones is a step backward for user freedom. Microsoft picking the same MIT-licensed base is the path of least resistance for a company that ships proprietary software. It also means Microsoft inherits a codebase that’s already proven at scale, since Ubuntu now ships it by default.

The bigger Microsoft-loves-Rust story

None of this is a one-off. It fits a pattern Microsoft has been building for a decade, ever since it stopped treating Linux as the enemy and started treating it as a platform its customers live on.

WSL was the opening move, letting developers run a real Linux userland inside Windows. The company has open-sourced old MS-DOS source code, pushed Rust into the Windows kernel, and watched its own developer tools go cross-platform. Coreutils for Windows extends that arc: instead of asking Linux developers to learn the Windows way, Microsoft is bringing the Linux way to Windows, and reaching for Rust to do it safely.

One thing to keep straight: what changed and what didn’t. Microsoft isn’t replacing Windows’ own commands. dir and copy still work; the new tools sit alongside them. And the company isn’t forking uutils into something proprietary, at least not yet. The repo at github.com/microsoft/coreutils is a packaging layer that pulls in the upstream Rust project and wraps it for Windows distribution. That’s a meaningful posture: Microsoft is consuming community open source and shipping its glue in the open, rather than rebuilding the wheel behind closed doors.

The Build 2026 keynote paired Coreutils with a second open-source release: an experimental Intelligent Terminal, a fork of Windows Terminal with an AI agent wired directly into the command line. It’s also MIT-licensed and installable through winget, the Microsoft Store, or GitHub. The pitch is that when a command fails, the terminal “automatically surfaces the context and suggests fixes you can run immediately,” with GitHub Copilot’s CLI as the default agent and support for any tool that speaks the Agent Client Protocol.

You can take or leave the AI angle. The deeper signal is consistent: Microsoft is shipping developer plumbing as open source, on permissive licenses, built or extended in Rust. The company that once ran the “Linux is a cancer” playbook now ports Linux’s command set onto its own OS. If you’ve watched tools like Notepad++ get a community Mac port or seen C# preview union types in the open, this is the same direction of travel, just at the level of the shell.

What this means for you

If you work across Windows, Mac, and Linux, this is a small quality-of-life win you can grab today: winget install Microsoft.Coreutils and your muscle memory stops fighting you on Windows. It won’t replace WSL for anything that needs a real Linux kernel, and it skips the POSIX-only commands, so check the list before you assume chmod is there.

The longer-term thing to watch is the license question, not the convenience. Every time a major vendor builds on the MIT-licensed Rust rewrite instead of the GPL original, the GPL version loses a little gravity. That’s great if you want permissive, embeddable system tools. It’s a worry if you think copyleft is what kept those tools free in the first place. Microsoft just put its weight behind one side of that debate. Where the rest of the ecosystem lands is the part still up for grabs.