Microsoft Developer
By baking container orchestration directly into WSL utility virtual machines, Microsoft eliminates external daemon dependencies and lets developers embed sandboxed Linux workloads natively into Windows applications.
AI-assisted summary of WSL improvements and the new Containers CLI and APIs | DEM346 — original source. Check the original for full context.
Source published:
Key ideas
- Microsoft announced native WSL Containers, allowing developers to execute Linux containers on Windows without third-party daemons or virtualization runtimes via the new wslc CLI or a programmatic NuGet package API. (0:01)
- The platform provisions dedicated utility virtual machines and isolated VHDs per application, enforcing hypervisor-level isolation and communicating via point-to-point Hyper-V sockets rather than network adapters. (16:39)
- WSL Containers uses Virtio-FS for cross-OS volume mounts, delivering roughly double the filesystem I/O performance of the legacy Plan 9 protocol between Windows NTFS and Linux containers. (19:42)
- A public preview is slated for late June, alongside upcoming WSL support for Microsoft's lightweight, container-optimized Azure Linux 3.0 distribution. (22:41)
Detailed notes
## Background Published by Microsoft Developer on YouTube on June 3, 2026, this Microsoft Build 2026 demo session (DEM346) is presented by Craig Loewen and Pooja Trivedi. According to the session description, it covers core end-to-end improvements to the Windows Subsystem for Linux (WSL) alongside a brand-new container command-line interface and programmatic APIs designed for Windows applications.
## TL;DR Microsoft introduces WSL Containers, bringing native Linux container orchestration directly into WSL without requiring separate third-party runtimes or background daemons. The architecture provides dual entry points: an interactive `wslc` CLI modeled on standard container tooling and a programmatic NuGet package (`WSLCSDK`) enabling Windows applications to embed isolated Linux workloads seamlessly. Under the hood, individual client applications and CLI workflows run inside isolated utility virtual machines communicating over point-to-point Hyper-V sockets, leveraging dedicated VHDs and Virtio-FS for high-performance host file sharing. The session also showcases hardware GPU passthrough for PyTorch AI compilation, enterprise compliance with Microsoft Intune and Microsoft Defender for Endpoint, and an upcoming container-optimized Azure Linux 3.0 distro package.
## Atmosphere & style The presentation is crisp, energetic, and thoroughly developer-centric, balancing rapid-fire terminal demonstrations with clear architectural breakdowns. Craig Loewen and Pooja Trivedi share an easygoing, tag-team rhythm, peppering live demos with lighthearted humor about avoiding 'Faustian rituals' and running destructive AI agents like 'Herbert' within safe blast radiuses. Watching it feels like a fast-paced technical deep dive where the excitement comes from eliminating traditional virtualization friction, culminating in production-grade showcases like DreamWorks' Moonray rendering engine running effortlessly on Windows.
## Bulletin - [00:01](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1s) Microsoft announced native WSL Containers, allowing developers to execute Linux containers on Windows without third-party daemons or virtualization runtimes via the new wslc CLI or a programmatic NuGet package API. - [16:39](https://www.youtube.com/watch?v=i0M13ZvL04M&t=999s) The platform provisions dedicated utility virtual machines and isolated VHDs per application, enforcing hypervisor-level isolation and communicating via point-to-point Hyper-V sockets rather than network adapters. - [19:42](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1182s) WSL Containers uses Virtio-FS for cross-OS volume mounts, delivering roughly double the filesystem I/O performance of the legacy Plan 9 protocol between Windows NTFS and Linux containers. - [22:41](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1361s) A public preview is slated for late June, alongside upcoming WSL support for Microsoft's lightweight, container-optimized Azure Linux 3.0 distribution.
## Key takeaways - [00:01](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1s) WSL Containers is built directly into the existing WSL package, requiring no standalone third-party container engines or background daemons. - [00:01](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1s) The platform is engineered for enterprise environments, integrating out of the box with Microsoft Defender for Endpoint (MDE) and Microsoft Intune. - [01:33](https://www.youtube.com/watch?v=i0M13ZvL04M&t=93s) The native wslc binary (aliased to 'container') mirrors open-source container commands like run, ps, build, and attach to preserve developer muscle memory. - [03:54](https://www.youtube.com/watch?v=i0M13ZvL04M&t=234s) Host port forwarding and volume binding operate natively across the virtualization boundary, complemented by over 160 GNU Coreutils ported directly to Windows PowerShell. - [07:07](https://www.youtube.com/watch?v=i0M13ZvL04M&t=427s) Hardware GPU acceleration is supported via a single flag (--gpus all), allowing containerized AI workloads to run PyTorch and compiled Triton kernels directly on host GPUs. - [09:07](https://www.youtube.com/watch?v=i0M13ZvL04M&t=547s) The architecture offers two entry points for the same underlying engine: interactive terminal workflows via wslc and programmatic embedding via the WSLCSDK NuGet package. - [09:07](https://www.youtube.com/watch?v=i0M13ZvL04M&t=547s) Microsoft designed WSL Containers to coexist with Docker Desktop, Rancher Desktop, and Podman, with core VM and filesystem optimizations benefiting the entire ecosystem. - [10:58](https://www.youtube.com/watch?v=i0M13ZvL04M&t=658s) Independent software vendors can run ephemeral Linux tools seamlessly, demonstrated by DreamWorks' Moonray ray-tracing engine executing via a short-lived VM without native Windows ports. - [14:02](https://www.youtube.com/watch?v=i0M13ZvL04M&t=842s) Developers can embed Containerfile recipes directly into .NET project files, enabling a unified F5 build, launch, and debugging inner loop in Visual Studio. - [14:02](https://www.youtube.com/watch?v=i0M13ZvL04M&t=842s) Host isolation and granular folder mounting restrict the blast radius of untrusted code or autonomous AI agents operating on local directories. - [16:39](https://www.youtube.com/watch?v=i0M13ZvL04M&t=999s) Each client application and the wslc CLI run inside an isolated, dedicated utility VM and manage runtime metadata in an independent VHD backed by the Moby container engine. - [16:39](https://www.youtube.com/watch?v=i0M13ZvL04M&t=999s) Host-to-guest instructions bypass network stacks, communicating directly between wslservice.exe and the container runtime via Hyper-V sockets (AF_HYPERV). - [19:42](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1182s) Cross-platform folder sharing adopts Virtio-FS, achieving approximately 2x performance gains over the Plan 9 (9P) protocol previously used by WSL. - [21:42](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1302s) Azure Linux 3.0 provides full single-vendor supply-chain attestation across Azure, AKS, and an upcoming lightweight distribution package for WSL.
## Detailed walkthrough ### [00:01](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1s) Three Core Takeaways of WSL Containers
Pooja Trivedi, an architect leading developer experiences in AI for Linux on Windows, introduces the session alongside Craig Loewen, a product manager working on the Windows Subsystem for Linux and developer AI tooling. Together, they unveil a major new capability: WSL containers. Craig emphasizes that attendees only need to retain three foundational takeaways about the project: local execution, frictionless integration into the existing Windows Subsystem for Linux, and enterprise readiness.
Developers will be able to run Linux containers natively and locally on Windows, either interactively using a new command-line interface or programmatically via an API embedded directly inside Windows client applications. Crucially, this is not a separate product requiring its own standalone deployment or complex setup; it is shipped as an integral feature of WSL itself. “So this will just be a new feature that you get directly as part of WSL,” Craig explains, noting that users will receive it automatically as an update to their existing setup. Finally, the platform is designed from day one to meet strict corporate compliance and security requirements, integrating smoothly with standard management suites such as Microsoft Defender for Endpoint (MDE) and Microsoft Intune.
- **Local Linux container execution:** Run Linux containers directly on Windows using an interactive CLI or a native API. - **Zero-friction delivery:** Built straight into the existing WSL package with no separate runtime or virtualization toolchain to download. - **Enterprise-ready compliance:** Operates seamlessly with industry-standard endpoint security and management infrastructure like MDE and Intune.
---
[01:33](https://www.youtube.com/watch?v=i0M13ZvL04M&t=93s) The `wslc` CLI and Basic Container Lifecycle
Transitioning directly into a live console demo, Pooja explains that once released, developers will gain access to the full suite of WSL container capabilities through a routine WSL update. She jokes that getting up and running requires “no downloading of third-party tools, no starting of daemons, no Faustian rituals.” Instead, WSL delivers a first-party command-line interface binary named `wslc`, which is also internally aliased to `container` for users accustomed to typing that command.
```mermaid flowchart LR accTitle: WSL Containers Architecture Engine accDescr: Diagram showing the CLI and API interfaces routing into the shared WSL virtual machine engine.
subgraph AccessDoors["Interaction Layers"] CLI["WSLC CLI / container"] API["NuGet Package API"] end
subgraph CoreEngine["Underlying Engine"] VM["Shared WSL Virtual Machine"] LinuxKernel["Linux Kernel & Container Runtime"] end
CLI --> VM API --> VM VM --- LinuxKernel ```
The syntax, subcommands, and flags of `wslc` mirror established open-source container tooling to ensure muscle memory carries over immediately. To showcase the baseline lifecycle, Pooja launches an interactive Debian Linux container using `wslc run -it debian`. While `wslc` typically pulls missing container images automatically from public container registries, she pre-cached the image on her laptop to bypass conference network instability. Inside the container shell, she demonstrates detaching cleanly via the standard `Ctrl+P, Ctrl+Q` key combination. Running `wslc ps -a` (or its equivalent, `wslc container list`) verifies that the Debian container remains alive in the background. She then reattaches to the session using `wslc attach` with the container name/ID, executes standard operations, and finally types `exit` to terminate the process, confirming its stopped state with another `wslc ps -a` query.
- **Command binary:** Shipped as `wslc`, with an internal alias to `container`. - **Familiar CLI syntax:** Supports standard subcommands including `run`, `ps -a`, `container list`, and `attach`. - **Interactive terminal support:** Standard `-it` switch supplies a pseudo-TTY and interactive stdin, detach sequence follows standard `Ctrl+P, Ctrl+Q`.
---
[03:54](https://www.youtube.com/watch?v=i0M13ZvL04M&t=234s) Building Custom Container Images and Host Integration
Beyond running stock distributions, developers frequently need to bring complex production or cloud microservices down to their primary Windows workstation for fast inner-loop development, testing, and debugging. Packaging workloads into containers eliminates the classic "works on my machine, fails in production" disparity. Pooja demonstrates this pattern by opening a standard `Containerfile`, which defines the exact software recipe, base layers, environment variables, dependencies, and entrypoint instructions needed to build an artifact.
Her demo project is an inspection utility named "Linux Spy," which runs a collection of Linux forensic and file-inspection tools against arbitrary uploads via an embedded web server listening on port 5000. The `Containerfile` starts from a minimal `python:3.12` base image, installs required system packages, copies the application source code into the container filesystem, specifies that port 5000 should be exposed, and defines the launch command. She compiles the image by issuing `wslc build -t mylinuxspy -f Containerfile.`.
Inspecting the local image registry with `wslc images`, Pooja pipes the output into `grep` directly within PowerShell. She takes a moment to highlight a major Windows ecosystem enhancement: Microsoft has ported roughly 168 native GNU/Linux coreutils directly into Windows, allowing native cross-platform terminal scripting. She then spins up the newly built image using port mapping (`-p 5000:5000`). Opening a browser on the Windows host and navigating to `http://127.0.0.1:5000`, she accesses the Linux Spy web UI locally, confirming that host-to-container port translation functions seamlessly across the virtualization boundary.
- **Reproducible builds:** Uses standard `Containerfile` / Dockerfile syntax to specify base layers, dependencies, and launch parameters. - **Build execution:** Executed directly from PowerShell via `wslc build -t <tag> -f <file>.`. - **Windows Coreutils:** Approximately 168 GNU Coreutils binaries are ported natively to Windows, enabling utilities like `grep` inside PowerShell pipelines. - **Port mapping:** Exposed internal ports are mapped to the Windows host with `-p <host_port>:<container_port>`, allowing direct access via `localhost` / `127.0.0.1`.
---
[07:07](https://www.youtube.com/watch?v=i0M13ZvL04M&t=427s) Hardware GPU Acceleration and AI Workloads
To highlight advanced performance capabilities, Pooja transitions from lightweight web services to a heavy local artificial intelligence workload that directly taps into the host machine's physical GPU. Running accelerated machine learning frameworks inside virtualized Linux containers on Windows has historically presented driver and passthrough friction. Under WSL containers, host graphics hardware is shared natively into the container environment with a single flag.
Pooja starts a pre-warmed container hosting a Jupyter Notebook web interface mapped to host port 8888. Inside the notebook, she initiates an end-to-end model fine-tuning pipeline using a GPT-2 transformer. The script downloads the weights, fine-tunes the network using PyTorch on the host's physical GPU, and invokes `torch.compile` to generate highly optimized, fused Triton kernels. To prove the execution efficiency, the notebook runs a benchmark race comparing the eager-mode baseline model against the Triton-compiled model, visually illustrating the massive inference speedup achieved by compiling kernels directly on the hardware.
Reviewing the terminal command used to launch the AI workload, Pooja breaks down the flags: ```text wslc run -it -p 8888:8888 -v <Windows_HF_Cache_Path>:<Container_Cache_Path> --gpus all <image_name> ``` The `-v` switch mounts the local Hugging Face cache directory from the Windows NTFS host directly into the Linux container path so massive model checkpoints are not re-downloaded or duplicated. Meanwhile, the `--gpus all` switch commands the WSL container runtime to bind all available host GPU compute resources straight into the containerized Linux environment.
- **GPU Passthrough flag:** `--gpus all` allows PyTorch, CUDA, and Triton to bind directly to host hardware inside the container. - **Host volume mounting:** Uses `-v` to share host directories (such as local model caches) directly across file systems. - **Kernel compilation:** Supports advanced compilation toolchains, including `torch.compile` and custom fused Triton kernels.
---
[09:07](https://www.youtube.com/watch?v=i0M13ZvL04M&t=547s) Dual Access Models and the Motivation for WSL Containers
Returning to the slide presentation, Craig summarizes the two distinct architectural entry points into WSL containers: the interactive `wslc` CLI and an upcoming programmatic API delivered via a NuGet package. He describes them as “basically two different doors for the same engine,” explaining that both the developer terminal commands and programmatic background calls funnel into the exact same lightweight WSL virtual machine that already powers standard WSL Linux distributions.
```mermaid flowchart TD accTitle: Targeted Audience for WSL Containers accDescr: Breakdown of customer profiles targeted by Microsoft for WSL containers.
WSLC["WSL Containers"] WSLC --> Prof1["Profile 1: Container Developers"] WSLC --> Prof2["Profile 2: Application Builders"]
Prof1 --> GoalA["Streamlined Setup on Windows"] Prof1 --> GoalB["Opinionated CLI + API Synergy"] Prof1 --> GoalC["Open-Source CoreVM Improvements"]
Prof2 --> GoalD["Embedding Linux Engines into Win32 Apps"] ```
Craig addresses the fundamental engineering question: why did Microsoft build a proprietary container CLI instead of simply bundling third-party tools like Docker, Podman, or Rancher Desktop? The answer centers on serving specific customer profiles with tightly coupled features. For everyday container developers, Microsoft wanted an opinionated, out-of-the-box solution where the command-line interface and client APIs operate in close harmony, permitting custom extensions and tight operating system integration.
Craig makes it clear that Microsoft is not attempting to displace the broader ecosystem: “However, those tools all work great, and if they still solve problems for you, you should use them.” Because WSL remains open source, any fundamental performance enhancements developed for WSL containers—such as cross-OS filesystem I/O optimizations between Windows NTFS and Linux ext4 virtual hard disks—accrue immediately to Docker Desktop, Rancher Desktop, and Podman Desktop running on top of WSL. Craig then introduces the second key target audience: application builders who want to embed self-contained Linux services and rendering runtimes directly into their Windows desktop software.
- **Dual-door architecture:** `wslc` CLI handles interactive local workflows; a dedicated NuGet package API allows programmatic application orchestration. - **Shared virtualization engine:** Both entry points utilize the same underlying WSL2 VM architecture that hosts standard Linux distributions. - **Ecosystem coexistence:** Docker Desktop, Podman, and Rancher Desktop remain fully supported and directly inherit underlying VM and cross-OS filesystem speed improvements.
[10:58](https://www.youtube.com/watch?v=i0M13ZvL04M&t=658s) Enterprise Management and the Moonray Rendering Engine Collaboration
The WSL Containers architecture is built directly for independent software vendors (ISVs) and enterprise IT administrators who want to bridge Linux ecosystems with Windows environments without introducing administrative headaches. Craig Loewen explains that enterprise IT teams often want to deploy modern Linux-based tools or AI agents locally within a containerized environment, yet need full operational visibility and the ability to manage machines through established Windows management tooling like Microsoft Intune and Microsoft Defender for Endpoint (MDE). Instead of dealing with an unmanageable, opaque virtual machine hidden on corporate endpoints, this setup preserves existing compliance controls: “I want to make sure that you get that powerful isolation without having to worry about your security tools not being able to break that boundary,” Craig notes.
```mermaid flowchart LR accTitle: Moonray Rendering Execution Flow accDescr: Diagram showing Windows host executing moonray.exe which launches an ephemeral WSL container VM, renders on the CPU, and outputs a JPEG back to Windows.
subgraph Host["Windows Host Environment"] EXE["moonray.exe (CLI Entry)"] Inputs["Render Files (*.rdlb)"] Output["Output Image (*.jpg)"] end
subgraph VM["Ephemeral Moonray VM"] Engine["Moonray Linux Engine"] Compute["CPU Raytracing"] end
EXE -->|"passes paths (C:\...)"| Engine Inputs --> Engine Engine --> Compute Compute -->|"renders JPEG"| Output Engine -.->|"shuts down on completion"| Host ```
To illustrate how seamless this model is for third-party software vendors, Craig highlights Microsoft's work with the team behind DreamWorks' open-source Moonray rendering engine. Moonray is an advanced, production-grade ray-tracing platform built exclusively for Linux and used in major animated feature films like *The Bad Guys 2* and *The Wild Robot*. In a live demo, Craig invokes `moonray.exe` from a standard Windows command prompt, supplying native Windows backslash file paths containing `.rdlb` (render input) files and instructing it to produce a `.jpg`. Behind the scenes, the WSL Containers API instantly spins up an ephemeral Moonray virtual machine, pegs the CPU to execute the ray-tracing calculations, outputs an image of a transparent orange coffee maker, and immediately terminates the utility VM to return all system resources back to Windows. Because the container startup and teardown happen within seconds, the tool operates indistinguishably from a native Windows binary.
- Moonray is an open-source, production ray-tracing engine built from the ground up on Linux. - IT teams can maintain endpoint visibility through standard enterprise management suites like Microsoft Intune and Microsoft Defender for Endpoint (MDE). - Container startup is nearly instantaneous, allowing short-lived CLI tasks to launch, process, and release hardware resources immediately.
---
[14:02](https://www.youtube.com/watch?v=i0M13ZvL04M&t=842s) Developer Inner Loop and the "Herbert" Blast-Radius Demo
To bring this execution model into everyday development workflows, the WSL team packaged the integration layer into a clean C#/.NET library. Pooja Trivedi points out that the entire lifecycle of the container and its hosting virtual machine is abstracted away from the end user: “All you're doing is you're creating and managing containers via the API.” In Visual Studio, developers add the WSL Containers NuGet package (`WSLCSDK`) to their project file. Inside the `.csproj`, an `<ItemGroup>` references the local `Containerfile` residing directly in the application source tree. Hitting F5 automatically builds the container image and launches the application alongside its containerized services as a single, unified debugging session.
To show the programmatic API in action, Craig showcases a playful sample application featuring an autonomous AI stock-trading agent named "Herbert." Running inside an isolated Linux container, Herbert manages mock equities on a virtual desktop while running real background services. However, Craig programmed Herbert with a destructive quirk: a routine that randomly deletes files off the filesystem. Because the container exposes a network port back to the Windows host, Craig inspects Herbert's operations through an integrated desktop viewer. When the agent deletes files, they are genuine filesystem deletions on the host, but restricted exclusively to an isolated directory mounted at `C:\temp\Herbert`. Craig explains that developers have precise control over network port forwarding and folder mounts: “You can specify, I only wanted to access this file on Windows. So I minimize the blast radius.” This sandbox guarantee allows untrusted or experimental code to manipulate host assets without risking system-wide damage.
- Container definitions (`Containerfile`) live directly alongside native source code in the project directory. - Developers experience a seamless F5 inner loop where container image building and launching happen automatically during project build. - Host integration supports granular directory mounting to enforce strict blast-radius controls against errant container processes.
---
[16:39](https://www.youtube.com/watch?v=i0M13ZvL04M&t=999s) Architecture: Hypervisor Isolation, WSL Service, and HV Sockets
Pooja Trivedi outlines the internal architecture powering WSL Containers, contrasting the Windows host environment with the underlying guest utility virtual machines. Rather than funneling every container into a single shared virtual environment, WSL provisions an independent, lightweight utility VM for every requesting Windows application, as well as an isolated VM dedicated to the `wslc` CLI flow. This model enforces a strict Hyper-V hypervisor boundary between individual client applications, eliminating naming collisions, network conflicts, and volume contention across distinct programs.
```mermaid flowchart TD accTitle: WSL Containers Architecture accDescr: Architecture diagram illustrating the host components communicating over an HV socket to the isolated Linux VM running the Moby container engine.
subgraph WindowsHost["Windows Host Operating System"] direction TB App["Windows App (via WSLCSDK)"] CLI["wslc.exe (Command Line)"] WSLService["WSL Service (wslservice.exe)"] VHD["App Virtual Hard Disk (*.vhdx)"]
App -->|"IPC"| WSLService CLI -->|"IPC"| WSLService end
subgraph GuestVM["Dedicated Utility Linux VM (per App / CLI)"] direction TB HVSock["Hyper-V Socket (HV Socket)"] Moby["Moby Container Engine"] Containers["Linux Containers"]
HVSock --> Moby Moby --> Containers end
WSLService <-->|"AF_HYPERV (Point-to-Point)"| HVSock VHD <-->|"/var/lib/docker Mount"| Moby ```
The system offers two primary entry points: the programmatic API via the `WSLCSDK` NuGet package, and the `wslc.exe` command-line executable. Both interfaces communicate over inter-process communication (IPC) with `wslservice.exe`, the long-standing Windows service responsible for managing WSL distribution lifecycles and host-guest communication. The WSL service was augmented to supervise container runtimes within the new utility VMs. To issue instructions to the Linux guest—which currently runs the open-source Moby container engine—the WSL service opens a Hyper-V socket (HV socket):
> “It is not a network socket, it's a specialized socket that is used specifically for communication between the VM and the hypervisor.” — Pooja Trivedi
Because an HV socket is a specialized point-to-point extension of the Winsock API (`AF_HYPERV`), it forms an isolated, hypervisor-mediated communication channel directly between `wslservice.exe` and the Moby runtime without touching traditional network stacks.
- Every Windows application running WSL containers receives its own dedicated utility virtual machine. - Container names, networks, and storage namespaces are isolated on a per-VM basis to prevent cross-app conflicts. - Host-to-guest instructions bypass general network adapters by using point-to-point Hyper-V sockets (`AF_HYPERV`).
---
[19:42](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1182s) Storage Separation and Virtio-FS File Sharing
Storage management in WSL Containers is decoupled across two tiers: persistent internal container data and host-mounted shared directories. For internal runtime data, the Moby container engine writes to a standard Linux storage directory (such as `/var/lib/docker`) containing container scratch layers, images, and runtime metadata. Under the hood, this entire directory is backed by an independent Virtual Hard Disk (VHD) on the Windows host. Each application and the CLI tool gets its own dedicated VHD, preventing distinct applications from viewing or corrupting each other's local container states.
```mermaid flowchart LR accTitle: Volume Mounting with Virtio-FS accDescr: Diagram showing a Windows folder mapped through Virtio-FS into a Linux container mount point.
subgraph Host["Windows Host Filesystem"] WinDir["C:\data"] end
subgraph Translation["Filesystem Protocol Layer"] Virtio["Virtio-FS (virtiofs)"] end
subgraph Guest["Container Environment"] LinuxMount["/data (Debian latest)"] end
WinDir <--> Virtio Virtio <--> LinuxMount ```
When an operator or application mounts a host folder into a container—such as running `wslc run -it -v C:\data:/data debian:latest`—the WSL runtime bridges the host folder (`C:\data`) to the container mount point (`/data`) using Virtio-FS (`virtiofs`). Virtio-FS is a modern shared-filesystem protocol specifically engineered to share file structures between hypervisors and virtual machines. Pooja emphasizes that translating POSIX and Windows filesystem semantics across distinct operating systems represents an engineering challenge. Compared to the Plan 9 (9P) networking protocol traditionally leveraged by WSL, Virtio-FS achieves substantial throughput gains: “Virtio-FS is about twice as fast as it stands today in this environment,” with additional performance optimizations underway.
- Internal container metadata, base layers, and writable scratch disks are encapsulated inside a dedicated `.vhdx` file per application. - Cross-platform volume binds rely on Virtio-FS (`virtiofs`) rather than the older Plan 9 protocol. - Current Virtio-FS implementations deliver roughly double the I/O performance of Plan 9 when translating semantics between Windows and Linux.
[21:42](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1302s) Azure Linux 3.0 Availability and WSL Distro Roadmap
Before concluding the presentation on WSL containers, the speakers take a quick detour to highlight another major development across the broader Windows Subsystem for Linux ecosystem: the general availability of Microsoft's Linux distribution, Azure Linux 3.0. Emphasizing its enterprise lineage, the presenter points out that this is the exact same distribution that runs Azure Kubernetes Service (AKS) and underpins Microsoft's broader Azure infrastructure today. Leveraging Azure Linux gives developers access to a highly consistent, battle-tested, and proven environment directly on their machines.
A central advantage of adopting Azure Linux is the end-to-end security and vendor consolidation Microsoft provides. Because Microsoft builds and maintains the full Linux operating system stack, organizations benefit from complete supply-chain attestation stretching from initial compilation straight through to final deployment. As the speaker explains:
> “Microsoft provides the entire stack for Linux, so it's a single vendor, full supply chain attestation from build to deployment.”
This unified model gives enterprise customers confidence and clarity regarding support, ensuring teams know precisely where to turn whenever issues arise. While Azure Linux 3.0 is currently accessible for virtual machines, a dedicated WSL distribution package is slated for release in the near future. The distribution is described as lightweight and container-optimized, making it a compelling option for local development when it lands on WSL.
```mermaid flowchart TD accTitle: Azure Linux 3.0 Ecosystem and Supply Chain accDescr: Diagram illustrating Azure Linux 3.0 powering both Azure AKS and WSL environments with full supply chain attestation.
subgraph SEC["Microsoft Supply Chain"] direction TB B["Build"] --> A["Attestation"] A --> D["Deployment"] end
subgraph TARGETS["Deployment Targets"] direction TB AKS["Azure Kubernetes Service (AKS)"] VM["Azure Virtual Machines (Available Today)"] WSL["WSL Distribution (Coming Soon)"] end
SEC --> AKS SEC --> VM SEC --> WSL ```
- **Azure Linux 3.0**: Now generally available for VM workloads and serves as the foundation powering AKS and Azure infrastructure. - **Supply Chain Security**: End-to-end verification and accountability backed by Microsoft as a single vendor. - **WSL Integration**: An upcoming container-optimized, lightweight Azure Linux distro tailored specifically for WSL environments.
---
[22:41](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1361s) Public Preview Timeline, Open Source Progress, and Q&A
Wrapping up the presentation, the speakers outline the roadmap for the WSL containers release and invite the community to test the tools against their everyday engineering tasks. Updates and release announcements will be published directly to the Windows Command Line blog as features go live. The team is explicitly seeking community engagement and hands-on validation, urging developers to put the software through its paces in real-world environments to help shape ongoing improvements.
The presenters target late June for the formal public preview milestone. As the project develops in the open, users are encouraged to follow development milestones, inspect the code, and file feedback within the public repository under the Microsoft organization on GitHub:
> “And we plan to thank you public preview by the end of June.”
At the conclusion of the session, the presenters open the floor for an in-person question-and-answer period, joined by the development lead for DreamWorks' MoonRay rendering engine to field specialized technical questions about their collaboration and real-time graphics container workflows on WSL.
- **Public Preview Launch**: Slated to arrive by the end of June. - **Blog & Updates**: New milestones and release notes will be shared via the Windows Command Line blog. - **Open Source Tracking**: Progress, issue tracking, and contributions continue at `microsoft/WSL` on GitHub. - **Live Q&A**: Follow-up discussion featuring the WSL engineering team alongside the MoonRay development lead.
## Notable quotes > [21:42](https://www.youtube.com/watch?v=i0M13ZvL04M&t=1302s) Microsoft provides the entire stack for Linux, so it's a single vendor, full supply chain attestation from build to deployment.
## Mentioned Craig Loewen, Pooja Trivedi, Windows Subsystem for Linux, wslc, Microsoft Intune, Microsoft Defender for Endpoint, Debian, PowerShell, PyTorch, Triton, CUDA, Jupyter Notebook, Hugging Face, Docker, Podman, Rancher Desktop, MoonRay, DreamWorks, WSLCSDK, Visual Studio, Moby, Hyper-V, Virtio-FS, Azure Linux 3.0, Azure Kubernetes Service
## Video description Learn about the new core end to end improvements to Windows Subsystem for Linux and the new Container CLI and Apis for your applications
Seating for this session is first-come, first-served. Add it to your schedule to plan your day and arrive early to secure a spot.
To learn more, please check out these resources: * https://aka.ms/build26/DEM346
𝗦𝗽𝗲𝗮𝗸𝗲𝗿𝘀: * Craig Loewen * Pooja Trivedi
𝗦𝗲𝘀𝘀𝗶𝗼𝗻 𝗜𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻: This is one of many sessions from the Microsoft Build 2026 event. View even more sessions on-demand and learn about Microsoft Build at https://build.microsoft.com
DEM346 | Windows
Demo | (400) Expert
#MSBuild
Chapters: 0:00 - Three key takeaways: local Linux containers, built into WSL, enterprise-ready 00:01:33 - WSL update provides full WSL Containers without extra installs 00:03:54 - Simple container workflow demonstration complete 00:09:07 - Transition Back to Slides: Summary of WSL Containers Interaction 00:11:56 - Introduction to Moonray rendering engine collaboration 00:14:02 - Explanation of transparent VM and API-based container management 00:17:26 - Overview of WSL containers architecture: Windows host and VM components 00:19:42 - Details on storage separation using VHD per application 00:23:02 - Closing remarks: public preview announcement and feedback invitation
[Source](https://www.youtube.com/watch?v=i0M13ZvL04M)