Microsoft officially took the wraps off its long-anticipated WSL Containers project on June 29, 2026, shipping a public preview that introduces wslc.exe and a native container API directly into the Windows Subsystem for Linux. The move immediately reignited a simmering question among Windows 11 developers: is this the moment to uninstall Docker Desktop and go all-in on WSL-native containers? The short answer, for the vast majority, is no—not yet. But that doesn’t mean you shouldn’t start testing.

The WSLC preview marks a turning point. For years, running Linux containers on Windows meant relying on third-party tooling, with Docker Desktop as the dominant intermediary. That added abstraction, licensing complexity, and resource overhead. With WSLC, Microsoft aims to collapse the stack: a lightweight runtime baked into WSL2, no extra VM, no daemon, no paid license for commercial use. The promise is simple—faster startup, tighter integration, and a container workflow that feels native to both Windows and Linux.

Yet a public preview, even one as polished as this, is not a green light for production migration. The developer community has learned hard lessons from betting on early-stage container platforms. The wise path is methodical evaluation, not wholesale replacement. Here’s what you need to know before you run wslc run on your main development machine.

What exactly is WSLC—and what does it change?

WSLC is not a new container runtime in the traditional sense. It’s an API layer and CLI tool (wslc.exe) that exposes native WSL2 functionality for building and running OCI-compliant containers. Under the hood, it leverages the same kernel, cgroups, and namespace isolation that WSL2 already provides to Linux distributions. No Hyper-V isolation, no Docker Engine, no containerd shim. The result is a dramatically simpler architecture: your container is just a WSL process with some extra confinement.

For Windows 11 users, this means you can pull an image, run a container, mount volumes, and forward ports without ever leaving the WSL terminal—or even from PowerShell, because wslc.exe is a Windows executable that communicates with the WSL sibling process. The API supports Docker-compatible Dockerfile builds, image caching, and basic compose-like functionality through a minimal declarative syntax. But it’s not Docker. And that’s both the point and the problem.

Where WSLC shines—and where it frustrates

Early adopters reporting in Windows forums highlight the speed. Containers start in under a second, compared to the 3–8 seconds many see with Docker Desktop’s Moby VM. Filesystem I/O, historically a pain point for Docker on Windows, feels nearly native because WSLC bypasses the 9p network file sharing and uses WSL2’s direct disk pass-through. GPU passthrough for AI workloads also works out of the box—something that requires elaborate configuration with Docker Desktop.

But the preview’s gaps are glaring. Network configuration is minimal; custom bridge networks and advanced port mapping are not exposed. Volume management uses WSL2’s own filesystem semantics, which means ownership and permissions can trip up cross-platform workflows. There’s no built-in registry mirroring, no Docker Swarm or Kubernetes integration, and no Docker Compose support beyond a rudimentary wslc compose that only handles a subset of the compose spec. If your workflow depends on multi-service orchestration, CI/CD integrations, or TLS-terminated reverse proxies, WSLC will feel clunky.

Microsoft’s preview documentation is candid about these limitations. They emphasize that the current release targets single-container development loops and lightweight CI runners—not full-stack environments. That honesty is refreshing, but it also puts the burden on you to figure out whether your daily work fits inside those boundaries.

The Docker Desktop elephant in the room

Docker Desktop isn’t just a container runtime; it’s a polished developer experience. The GUI, the extensions ecosystem, the volume management dashboard, the automatic updates—none of that exists in wslc.exe. For solo developers or small teams who value turnkey simplicity, that missing UX is a dealbreaker.

More consequential is the licensing angle. Docker Desktop’s 2021 shift to a subscription model for large enterprises pushed many organizations to seek alternatives, fueling interest in Podman, Rancher Desktop, and now WSLC. If your company pays for Docker Desktop licenses primarily to run Linux containers on Windows developer machines, WSLC could slash costs. But until it matches the reliability and tooling, the savings may be illusory—lost productivity and debugging time easily outweigh a subscription fee.

The preview does include a wslc export docker command that generates a Docker-compatible context, allowing you to switch between WSLC and a remote Docker daemon. That’s a smart hedge, enabling partial adoption without committing entirely. You can prototype a service with WSLC and, if you hit a wall, pivot to Docker with minimal friction.

Who should start testing now?

If you fall into one of these groups, the WSLC preview deserves a dedicated afternoon of experimentation:

  • Backend developers working on single-service Node.js, Python, or Go apps. You’ll get the biggest speed wins and are least likely to need orchestration features.
  • ML engineers using GPU-accelerated containers. WSLC’s native passthrough is easier than Docker’s --gpus setup.
  • CI/CD pipeline maintainers evaluating Windows-based build agents. A headless WSLC agent could run containers faster and with less overhead than Docker-in-Docker.
  • Open-source contributors who want to remove Docker Desktop’s licensing from their toolchain.

Everyone else should keep Docker Desktop (or an established alternative) as the default, and use WSLC only for side experiments. Don’t uninstall Docker—just add wslc.exe alongside it and start profiling performance on real workloads.

A practical test plan in five steps

If you’re ready to take the preview for a spin, follow this structure to get meaningful data without breaking your workflow:

  1. Install the preview on a non-critical machine or a dedicated WSL distribution. Microsoft provides an MSI package that drops wslc.exe into C:\wslc\bin. You’ll need Windows 11 build 25987 or later and WSL2 version 2.4.0 or higher.
  2. Replicate an existing Dockerfile-based project. Use wslc build -t myapp . and note the build time. Compare it with docker build on the same hardware under Docker Desktop.
  3. Run the container and measure startup latency. Script a simple HTTP healthcheck and time from wslc run to the first 200 OK. Also test file-change hot reloads if your framework supports them.
  4. Test volume mounts intensively. Share a large directory tree (e.g., node_modules) and benchmark git status, file writes, and inotify responsiveness. This is where Docker Desktop historically stumbles.
  5. Check network firewalling and multi-container setups. Try running a database container alongside your app. If you rely on Docker Compose’s depends_on with healthchecks, you’ll need to script your own readiness checks in WSLC.

Throughout testing, log every friction point. The WSLC team has been actively soliciting feedback via GitHub issues, and the most useful reports will come from real-world comparisons, not synthetic benchmarks.

The competitive landscape beyond Docker

It’s worth remembering that WSLC isn’t entering a vacuum. Rancher Desktop uses Kubernetes-native tooling under a Docker-compatible facade. Podman offers a daemonless, rootless container engine with strong Systemd integration. Lima provides a generic Linux VM with declarative templating. Each has wrestled with the Windows compatibility problem, and each has matured over years of community pressure.

WSLC’s differentiator is deep OS integration. Because it lives inside WSL2, it inherits Windows’ power management, security policies, and update cadence for free. No extra VM to patch, no separate network bridge to manage. For enterprise IT departments sick of wrangling third-party hypervisors, that’s a compelling pitch.

But the preview’s success will hinge on how quickly Microsoft closes the feature gap. The roadmap teased in the announcement includes multi-container orchestration, a REST API for remote management, and a Visual Studio Code extension. If even half of those land before the 1.0 release, Docker Desktop will face genuine headwinds on Windows.

Real-world voices from the developer trenches

Though Microsoft’s blog post focuses on architecture, the Windows forum threads tell a more nuanced story. Several developers report that the preview works flawlessly for single-container web apps but breaks unpredictably when they integrate databases or message queues. One user discovered that wslc logs doesn’t support follow mode, making real-time debugging a chore. Another noted that image layer caching is more aggressive than Docker’s, leading to confusing rebuilds when only a single file changes.

These are exactly the kind of papercuts that separate a good preview from a production-ready tool. They aren’t showstoppers, but they add friction to daily development. The forum consensus aligns with our recommendation: test, but hold off on migrating your main setup.

What happens next

Microsoft hasn’t published a release date for WSLC 1.0, but the public preview milestone suggests a launch within the next 6–12 months. The team has a strong track record with WSL itself—what began as a quirky compatibility layer is now a cornerstone of Microsoft’s developer outreach. If WSLC follows the same trajectory, it could become the default container runtime on Windows 11 by mid-2027.

Until then, treat WSLC as a fast-moving experiment. It’s a glimpse of a Docker-less future, one that many developers have been clamoring for. But it isn’t ready to carry your production build pipeline on its shoulders. Keep Docker Desktop installed, keep testing wslc.exe, and keep sending feedback. The moment to switch will come—it’s just not here yet.