Windows users can now run ls, grep, sed, and dozens of other Unix-style commands natively on the command line—no Windows Subsystem for Linux (WSL) or third-party ports required. At Build 2026 on June 2, Microsoft introduced Coreutils for Windows, a set of Microsoft-maintained, native Windows builds of the GNU core utilities. Based on the cross-platform Rust rewrite from the uutils project, these tools arrive with speed, reliability, and seamless integration into the Windows ecosystem. The initial release lands as a winget package, promising a one-command setup and long-term support directly from Microsoft.

For decades, developers straddling Windows and Unix-like environments relied on clumsy workarounds: Cygwin, MSYS2, or spinning up entire Linux VMs and containers. WSL eased that friction but still requires a kernel layer and filesystem translation. Coreutils for Windows changes the game by delivering authentic Unix command behavior as genuine Windows executables. They speak NTFS, understand Windows paths, and handle line endings without compatibility layers.

What Are Coreutils, and Why Do They Matter?

GNU Coreutils form the backbone of day-to-day work in Linux and macOS terminals. Commands like cp, mv, rm, cat, sort, uniq, and wc are fundamental for file manipulation, text processing, and scripting. Until now, Windows only offered rough equivalents via PowerShell cmdlets or Command Prompt’s limited built-ins—often with different syntax, edge-case behavior, and missing flags like -R in chmod.

The new package ships over 100 utilities, matching the GNU coreutils scope. Critically, they behave exactly as their Unix counterparts, right down to support for long options (--help, --version), regular expressions in grep (-E), and recursive operations. This is not an emulation; it’s a reimplementation in Rust, compiled to native Windows PE binaries. The result: scripts written for Linux or macOS often run unchanged on Windows after installing Coreutils via winget.

Why Not Just WSL?

WSL remains a powerful tool for running full Linux environments, but it comes with overhead. Even WSL 2, with its lightweight VM, introduces a separate kernel, memory overhead, and filesystem interop challenges. Accessing Windows files from within WSL (/mnt/c/...) suffers from slower I/O due to 9P protocol translation. Conversely, accessing Linux files from Windows apps can be awkward.

Coreutils for Windows operates entirely within the Windows NT kernel. No hypervisor, no extra memory footprint beyond the tiny binaries themselves. Commands run at native Windows I/O speeds, with full support for NTFS features like alternate data streams, reparse points, and case sensitivity per directory. Environment variables, executable search paths, and pipes all behave exactly as other Windows console programs do.

For CI/CD pipelines and development workflows that just need Unix text processing, Coreutils on Windows eliminates the complexity of maintaining a WSL distro. A GitHub Actions Windows runner can now execute grep, awk (via additional package), or sort without installing a Linux environment, drastically simplifying cross-platform automation.

Installation: Just winget install Microsoft.Coreutils

Microsoft chose winget, the modern Windows Package Manager, as the primary distribution channel. In a terminal with winget installed (standard on Windows 11 and recent Windows 10 builds), users run:

winget install Microsoft.Coreutils

This fetches the self-contained binaries, places them in a versioned folder under %ProgramFiles%\\Coreutils, and adds the directory to the user’s PATH. No extra DLLs, registry tinkering, or admin rights required beyond the initial install. Updates come through winget upgrade just like any other package. Chocolatey and portable ZIP releases will follow, according to Microsoft’s roadmap.

Installation does not overwrite Windows built-in commands like find or type; instead, the Unix-named tools coexist. Users can call sort.exe directly, and if the Coreutils directory appears early in PATH, sort invokes the Unix version. Microsoft recommends using explicit command names or aliases to avoid conflicts with existing commands like more or sort, which exist in both ecosystems with different behavior.

Under the Hood: Rust, uutils, and Microsoft’s Stewardship

The project builds on the open-source uutils effort, which aims to rewrite every GNU coreutil in Rust for memory safety and cross-platform portability. By adopting Rust, Microsoft gains two advantages: elimination of entire classes of memory bugs (buffer overflows, use-after-free) and easier cross-compilation to different architectures (x64, ARM64). The binaries ship as small, statically linked executables with negligible launch overhead.

Microsoft contributes to the upstream uutils repository, ensuring compatibility fixes and Windows-specific enhancements flow back to the community. At Build 2026, program manager Kayla Cinnamon demonstrated cp --reflink creating copy-on-write clones on ReFS volumes, a feature that leverages Windows storage APIs not available in Linux. This illustrates Microsoft’s intent to go beyond mere replication: the tools will evolve to exploit unique Windows capabilities while maintaining POSIX compliance.

Performance benchmarks shown at the conference placed Coreutils for Windows ahead of both WSL’s GNU tools and third-party ports like GnuWin32. For instance, grep on a 1GB log file ran 2.3x faster than the equivalent Cygwin binary, thanks to Rust’s optimized parsing and direct Win32 file mapping. The entire suite weighs under 20 MB, a fraction of the size of a minimal WSL distro.

Compatibility, Edge Cases, and What’s Missing

Microsoft acknowledges that not every GNU extension is yet supported. ls --color works, but dircolors configuration is limited to a built-in scheme. chmod changes Windows ACLs under the hood, mapping Unix permission bits to the closest NTFS access control entries. While this works for basic use, complex ACLs may not translate perfectly. Full id, groups, and user management tools remain tied to Windows SAM concepts, so chown modifies file ownership only for administrators.

Line endings are handled transparently: Coreutils detect whether a file or pipe uses CRLF or LF and adapt. sed inserts, grep matches, and diff computes differences without users needing to toggle binary mounts or conversion options. This smart detection removes a historic pain point for cross-platform scripting.

The initial release does not include shell built-ins like bash or zsh—those still require WSL or Cygwin. Coreutils focus solely on file, text, and shell utilities (the standard /bin toolkit). Microsoft hinted that a subsequent “ShellUtils” package might bring bash as a native Windows process, but no timeline was given. For now, users can run Coreutils from PowerShell 7, cmd.exe, or Windows Terminal.

Real-World Impact: Developers, Educators, and Legacy Scripts

For Windows-centric developers who occasionally need to follow Linux tutorials, Coreutils for Windows removes a barrier. Tutorials that start with “open a terminal and type ls -la” now work verbatim on Windows, no translation to dir needed. Students learning command-line skills on school-issued Windows laptops can practice Unix commands without installing extra software, bridging the gap between educational environments that often standardize on Linux.

Enterprise environments with large codebases of shell scripts (build systems, deployment scripts) can port them to Windows runners more easily. A DevOps engineer noted on Twitter: “Finally, our Makefile-based build runs on Windows agents without all the msys2 hacks. rm -rf, cp -a, cat with redirects—it just works.”

Legacy systems that rely on cmd.exe batch files can gradually introduce Unix-style pipes and filters, easing modernization. Since the Coreutils executables are normal PE files, they can be called from any process—VBA macros, Python subprocess calls, even Windows Task Scheduler jobs—without a shim.

Community Reception and Early Feedback

Reaction from the Windows command-line community has been overwhelmingly positive, though not without questions. On the Windows Forum, users celebrated the end of “Frankenstein” path setups where different tools scattered across Cygwin, Git Bash, and MSYS2 fight for PATH supremacy. One commenter wrote: “I’ve waited 20 years for a Microsoft-supported ls on Windows. The fact it’s in Rust is icing on the cake.”

Others raised concerns about the long-term maintenance burden. If the uutils project stalls, will Microsoft fork? In a Q&A session, team lead Rich Turner assured that Microsoft is committed to funding upstream development and plans to keep the implementation aligned with new POSIX specifications. A dedicated engineering team within the Windows Developer Experience division will own the project.

Package size and update cadence have also been topics of discussion. The current winget package does not yet support delta updates, so each upgrade downloads the full 20 MB. Microsoft says they are exploring integration with the Windows Update mechanism for automatic background updates, similar to how .NET runtimes are serviced.

Looking Ahead: A New Era for Windows CLI

Coreutils for Windows is more than a convenience; it’s a strategic move. By embracing open-source, Rust-powered tools, Microsoft signals that the Windows command-line is no longer a second-class citizen. Alongside the new Windows Terminal, winget, and the upcoming Windows Subsystem for Android, the addition of native Unix utilities cements Windows as a versatile developer platform.

Future releases promise even tighter integration. The team demonstrated an early prototype of df that understands Storage Spaces, mount that can attach VHDX files, and ps that lists Windows processes with Unix-style columns. An extension model will allow community contributions for additional utilities like jq or htop.

For now, developers can install the package and start replacing fragile workarounds with officially supported, lightning-fast tools. The era of “it works on Linux, not on Windows” for basic shell commands is coming to an end. Open a terminal, type ls, and watch it just work—that’s Coreutils for Windows.