Microsoft has been rethinking its commitment to Windows for a while now, with Insider builds of the operating system showing a swing away from web-based user experiences and back to native code. That commitment got a boost at Build 2026 with a bundle of announcements that focused on tools and features that help developers take advantage of the platform.

The most obvious is support for the standard core Unix utilities, in the shape of a Microsoft-maintained fork of the popular Rust-based uutils coreutils package, Coreutils for Windows. Coreutils for Windows installs as a single binary, making it easier to update and manage. And it is one of those tools that does exactly what it says on the tin, providing a Windows implementation of the commands you’re using in Linux virtual machines or in Windows Subsystem for Linux (WSL).

Building on Windows Terminal with Coreutils

Much of the Windows developer experience has moved back to the command line via Windows’ rearchitected terminal, underscoring the need for a consistent experience across the multiple development environments running on your PC. The context switch between a Linux environment through WSL or in a Visual Studio remote terminal and the Windows PowerShell and cmd environment can be jarring.

I often find myself typing a Unix command in Windows and vice versa, seeing an all-too-familiar error message, followed by trying to remember what I should have typed, and finally trying again. It wastes time and fills my terminal buffer with junk.

Microsoft Coreutils solves the problem by handling Unix commands for me. It not only provides the same command syntax, but also formats the output correctly. It’s a little odd seeing a well-presented directory listing in Windows when typing ls -al. But once you get used to it, having the same experience on all your systems saves time and avoids having to switch context every time you open a new terminal tab or when you switch back from a SSH session.

There’s another advantage to having Coreutils in Windows: scripts written for a Unix system will port to Windows. This can help with common operations, like builds, or writing your own custom functions.

It’s important to note that Coreutils for Windows is only a preview for now, and not all the Coreutils functions are fully implemented. There are inevitably conflicts with existing cmd and PowerShell commands, so for example, Microsoft’s Coreutils doesn’t ship with the familiar more or dir commands. Other commands, like kill, can’t be implemented at present because Windows doesn’t support the Unix signals model. And still others won’t ship because they’re based on low-level Unix concepts, like groups and owners, that are part of POSIX but not Windows. Microsoft provides a list of other issues on the project’s GitHub Readme, along with suggestions for alternatives that can be helpful. For example, as Windows doesn’t have /dev/null, you can replace it with NUL in scripts.

Getting started is simple. You can download the latest release from GitHub or use winget to download and install from the command line. For now, I’d recommend using winget, as it provides an update mechanism as well as an uninstaller. It’s well worth adding to your Windows environment. It is already making my life a lot easier.

Fast track setup with Windows Developer Config

Another important tool that gets a public release is Windows Developer Config. This builds on the techniques used to configure cloud-hosted Microsoft Dev Boxes and brings them to any Windows PC, using winget and other tools to build out a ready-to-run development PC. Dev Configs aren’t only for Windows. They also work on Linux VMs or in WSL, so that all the environments you use to write code can be configured with your tool chains and more.

There are three parts to the Dev Config process: a set of winget configurations to install familiar tools and tune Windows, a set of scripts to enable cloud-native development scenarios and workloads, and a set of scripts that configure WSL to work with your choice of shell, distribution services like Homebrew, and your distribution’s installation and update mechanisms.

The three options are open source, with all the necessary files on GitHub. It’s important to note that while the tooling is opinionated, it’s not prescriptive. If you want to extend the winget configuration to add a feature like Coreutils, you can. The default configuration is intended to be the same as that delivered when you spin up a Dev Box Cloud PC virtual machine, and the tooling uses the same techniques including the PowerShell-based Desired State Configuration to ensure that existing tools are updated as necessary.

Having a service that delivers the same environment as a Dev Box makes perfect sense. Microsoft has been using these tools internally, and its fast network makes Cloud PCs easy to use. However, that’s not the case for all of us, where slow networks and cloud latencies make it hard to use hosted virtual environments. We might even want to use those resources when we’re on the move, working with checked-out Git repositories on a train or in a plane, where bandwidth is not reliable.

Setting up a PC with the base Dev Config is as easy as it should be. Winget’s configuration service runs on both new and old PCs, installing applications where needed, running updates where necessary, and applying the necessary developer settings to Windows. You can download the scripts by cloning a GitHub repository (if Git is already installed) or by downloading a zip archive. Microsoft provides instructions for both options, along with the command and options used to start the process. Your PC may reboot as part of the process of installing WSL, but the script is designed to restart once it’s up and running again. It’s idempotent, so you can run it regularly to avoid configuration drift.

The apps installed include the latest PowerShell, Git, CLIs for GitHub, GitHub Copilot, the Windows App SDK, Visual Studio Code, and language support for Node.js, Python, and .NET. The install brings in developer-friendly fonts and a theme engine for the Windows Terminal. Other features include customizing File Explorer and the Windows Task Bar, as well as hiding notifications to improve focus.

Tweaking WSL for Comfort

With WSL installed, you can use the WSL Comfort scripts to install additional tools and customize Windows Terminal. This is a two-part tool. The Windows part ensures WSL and Ubuntu are installed and sets up fonts and terminal profiles. The Linux part then tunes the WSL environment, with the option of switching to zsh and using the starship terminal display tools. It then adds a series of popular CLIs and support for the Homebrew package installer. You don’t need to install a new Linux distribution in WSL; you can target your existing Ubuntu instance.

The result is a developer-focused WSL installation with much of the required configuration already installed, along with the basis of a Linux development toolchain — including some of my favorite tools that are already part of my default install. With this new script I don’t have to install them manually (and configure necessary apt repositories); it’s all automated.

The underlying winget configuration tools can be used to prepare your development PC for specific workloads. These are installed in a workload directory and set up your environment to work with your choice of platforms. This way you can have all the tools you need to work with TypeScript or Java ready to go. Some of the workload installers download a lot of resources. If you’re setting up for WinUI 3 development, for example, be prepared to download several gigabytes of Visual Studio and the Windows Application SDK. This will take time and will overload a machine or VM without the required space.

There are a lot of tools here, with more on the way. The roadmap includes plugins for the Windows PowerToys command palette, putting Windows Dev Config a few keystrokes away from your desktop. Microsoft is finally filling one of Windows’ missing pieces, providing a quick and easy way to build a developer-ready environment that can be customized to work the way you want. For development teams, these tools enable the consistency across environments needed to share code and ideas, along with being able to pick any keyboard and start working without having to worry about the time needed to learn someone else’s setup.