Microsoft Ships Native Linux Container Toolkit in WSL 2.9.3 Preview on Windows 11

Microsoft dropped a long-awaited capability into the hands of developers on June 29, 2026, with the first public preview of WSL Containers—dubbed WSLC—bundled in WSL 2.9.3 for Windows 11. The release introduces a new wslc command-line tool that lets users build, run, and manage Linux containers directly from a WSL distribution, without requiring Docker Desktop or any third-party container runtime. The move streamlines the container workflow on Windows and doubles down on Microsoft’s commitment to making the OS a first-class platform for cloud-native development.

For years, running Linux containers on Windows meant choosing between Docker Desktop, Podman, or installing a full Linux VM. WSL 2 already provided a lightweight virtual machine with near-native Linux kernel performance, but container orchestration still relied on external tooling. WSLC changes that by baking container management into WSL itself. Microsoft is positioning wslc as the native, minimal-friction path from code to container for developers who live in the terminal.

The preview ships with WSL version 2.9.3, available immediately through the Windows Insider Program on Windows 11. It marks a significant step in the evolution of the Windows Subsystem for Linux, transforming it from a compatibility layer into a self-contained development environment that can rival standalone Linux workstations for containerized workloads.

What Exactly Is WSLC?

WSLC stands for WSL Containers—a native container management solution built into WSL 2. It is not a separate product but a set of components and commands that extend the WSL kernel and user-space utilities. At its core, wslc is a single binary that talks directly to the WSL Linux kernel’s built-in container primitives (namespaces, cgroups, overlay filesystems) to create and manage OCI-compliant containers.

Unlike Docker, which relies on a daemon (dockerd) running in the background, wslc is daemonless. Each container is launched as a child process of the wslc command, reducing overhead and eliminating the need to start a persistent service. This design mirrors modern container tools like Podman but is tightly integrated with WSL’s own lifecycle. When you terminate a WSL distribution, all associated containers stop gracefully. No orphaned zombie processes, no extra resource consumption.

The initial preview supports a subset of the OCI runtime specification, enough to run most common Linux application stacks. Microsoft has confirmed that wslc uses the same kernel as the active WSL 2 instance, so containerized applications access filesystem, networking, and hardware acceleration with no virtualization penalty. GPU passthrough for AI/ML workloads works out of the box if the host has WSL’s GPU driver installed.

The wslc Command: Build, Run, Manage

The star of the show is the wslc CLI. Its syntax deliberately echoes familiar container tools, making the transition easy for developers already versed in Docker or Podman. Key operations include:

• wslc build – Builds an OCI image from a Containerfile (Microsoft’s chosen name for what many know as a Dockerfile). The preview includes an embedded BuildKit-derived builder, so multi-stage builds, caching, and secret mounts are supported.
• wslc run – Creates and starts a container from an image. Options like -p for port mapping, -v for volume mounts, and --env for environment variables are all present.
• wslc ps – Lists all running containers across WSL distributions.
• wslc stop, wslc rm – Stop and remove containers. wslc images and wslc rmi manage local images.
• wslc push / wslc pull – Interact with any OCI-compliant registry (Docker Hub, Azure Container Registry, GitHub Container Registry, etc.). No separate login step; wslc reads credentials from the standard Docker config file (~/.docker/config.json) if present, or you can run wslc login.

Initial feedback from early adopters praised the command’s responsiveness. Because wslc does not proxy requests through a daemon, container start times are noticeably faster than with dockerd on WSL 2. One Microsoft engineer demonstrated launching a Node.js container in 0.8 seconds from a cold start, compared to 3.2 seconds with Docker Desktop under identical conditions.

How It Differs from Docker Desktop

The most immediate question from the community is whether WSLC aims to replace Docker Desktop. The short answer: not yet, but it offers a compelling alternative for many use cases. Docker Desktop bundles a full Grafical user interface, Kubernetes cluster, extensions marketplace, and enterprise policy controls. WSLC is purely a command-line tool, targeted at developers who prefer lightweight setups and are comfortable with terminal workflows.

There are other important differences:

Microsoft has confirmed that WSLC is open source (MIT license) and that the company will maintain it alongside WSL. The long-term goal is to make wslc a fully conformant OCI runtime that can serve as a drop-in replacement for runc or crun, but with deep WSL integration.

Getting Started with WSLC

To try WSLC, you need:

• Windows 11 build 26200 or higher (Dev Channel as of June 2026)
• WSL version 2.9.3 (install or update with wsl --update –pre-release)
• A WSL distribution running a recent kernel (automatically provided by the WSL update)

Once updated, open any WSL terminal and run:

wslc version

If the output shows a version string (preview builds show “0.9.0‑preview1”), you are ready to go. Pull an image and run a container:

wslc pull alpine:latest
wslc run -it alpine /bin/sh

Builds work the same way:

mkdir myapp && cd myapp
echo -e 'FROM alpine:latest
CMD echo "Hello from WSLC"' > Containerfile
wslc build -t myapp:latest .
wslc run myapp:latest

Note that the tool uses the name Containerfile by default, though Dockerfile is also supported for backwards compatibility.

Since WSLC lives inside WSL, it inherits all WSL networking features. Containers can be accessed from the Windows host via localhost using the same port mapping that wslc run defines. Windows Defender Firewall automatically recognises WSL traffic, so no manual rule configuration is needed.

Real‑World Use Cases

WSLC immediately addresses several pain points reported by the WSL community over the years:

• CI/CD pipelines: Running a self‑hosted GitHub Actions runner or Azure DevOps agent inside WSL? Now you can build and test containers without installing Docker Engine separately. The daemonless model reduces CI setup time from minutes to seconds.
• Development environments: A developer can spin up a PostgreSQL database and a Redis cache using wslc run in one terminal, and code their application in another, all within the same WSL distribution. Shutting down WSL cleans up everything.
• Learning and experimentation: Students and newcomers can start learning containers without signing up for Docker Hub or configuring complex daemon settings. wslc works offline once images are cached.
• Edge and IoT: For Windows 11 IoT Enterprise installations that run WSL, wslc provides a minimal container runtime that fits resource‑constrained devices.

Microsoft also hinted that WSLC will eventually integrate with Visual Studio Code’s Dev Containers extension, enabling VS Code to detect WSL‑native containers and offer a seamless attach experience. With dev containers already popular among Windows developers, this would close the loop between editor and runtime.

Performance and Security

Because WSLC shares the WSL 2 kernel, there is no double‑virtualization penalty. Containers run at bare‑metal speeds inside the lightweight Hyper‑V VM that WSL 2 uses. Early benchmarks show I/O throughput within 1–2% of a native Linux install on the same hardware. This is a stark contrast to some third‑party solutions that layer another virtual machine on top of Hyper‑V.

Security‑wise, wslc leverages user namespaces and seccomp profiles out of the box. Containers run rootless by default—the container’s root user is mapped to a non‑privileged user on the host (the WSL user). This reduces the risk of container breakout, which has been a historical concern with Docker daemon running as root. Microsoft’s security team has also locked down the system call table used by WSL, blocking several high‑risk calls that are commonly exploited in container escapes.

The preview does not yet support image signing or Notary v2 attestations, but the roadmap includes Cosign integration before general availability.

Community Reception and Early Feedback

While the WSLC preview is only a few days old, the initial response in developer forums has been enthusiastic. Many Linux‑focused Windows users have expressed relief at finally having a first‑party container tool that doesn’t feel bolted on. One early tester noted, “I’ve always wanted WSL to just be my CI runner without extra setup. wslc removes the last friction point.”

However, some developers have pointed out missing features that block adoption in production workflows:

• No Docker Compose support – orchestration of multi‑container applications remains cumbersome. Microsoft says Compose file parsing is on the short‑term roadmap.
• No volume driver plugins – only bind mounts and WSL’s native 9p filesystem mounts are supported.
• Limited networking modes – host networking is not yet implemented, which complicates some microservice setups.

The WSL team has responded quickly on GitHub issues, acknowledging the gaps and asking for upvotes to prioritise features. Given the preview nature, polished documentation is still sparse, but the --help output for wslc is detailed and includes examples.

What This Means for the Windows Development Ecosystem

The arrival of WSLC signals a strategic shift for Microsoft. For years, the official recommendation for containers on Windows was Docker Desktop, a product built by a close partner. Introducing a native competitor—even an open‑source, developer‑focused one—subtly changes the landscape. It gives enterprises a Microsoft‑supported option that may simplify licensing and security compliance, especially in air‑gapped environments where installing external software is difficult.

It also aligns with broader industry trends toward daemonless, rootless container runtimes. Podman’s rising popularity proved that developers value simpler, more secure container management. Microsoft is borrowing those ideas and wrapping them in familiar WSL convenience. The company has been careful to stress that WSLC is not a Docker Desktop killer; rather, it expands the toolbox for developers who want a minimal, CLI‑first experience.

That said, competition is likely to accelerate improvements on both sides. Docker has already announced a new “WSL‑native mode” for Docker Engine that reduces memory overhead, and Podman’s Windows installer now offers a WSL backend. The result is better tools for everyone.

Looking Ahead: The Road to General Availability

Microsoft has not yet committed to a GA date, but the preview quality suggests the fundamentals are solid. According to the public roadmap, the next milestone (preview 2) will add:

• wslc compose for Docker Compose v2 files
• Support for --network host
• Improved build caching across WSL distributions
• A --wsl‑mount option for mounting Windows drives directly

Longer term, the team is exploring wslc integration with Windows Admin Center for server management, and a wslc‑init systemd unit generator that can convert docker-compose.yml into systemd services inside WSL.

One intriguing possibility hinted at in a recent Microsoft Developer blog is the ability to run wslc containers across multiple WSL distributions simultaneously, using a shared image store. That would let you isolate projects in separate environments without duplicating common base images—a space‑saving feature not yet seen in other container tools.

Conclusion: A Native Container Runtime That Feels Inevitable

With WSLC, WSL takes a logical next step. What began as a compatibility layer to run bash on Windows has matured into a full‑fledged development runtime capable of building and hosting containerised applications without external dependencies. The wslc command is simple, fast, and rootless by design—values that resonate with the modern developer ethos.

For the millions of Windows users who rely on WSL daily, this preview is more than a new feature; it’s a sign that Microsoft understands where development is headed. Containers are no longer an afterthought; they are the default. And now, Windows has a native answer.

The preview is ready to try today. If you run Windows 11 and have WSL installed, update to the pre‑release kernel and launch a container with wslc run alpine. You might find that the path from laptop to cloud just got a little shorter.