Microsoft shipped WSL Kernel 6.18.35.1 on June 12, 2026. The release, delivered through the WSL2 Linux kernel project, bumps the Windows Subsystem for Linux 2 to upstream Linux 6.18.35 and includes a critical virtio-fs fix that corrects file write failures when data crosses a 4 GB boundary. For developers pushing large files, container images, and database tables across the Windows–Linux filesystem bridge, this patch removes a sting that has been tripping up workflows for months.

The update also bundles a DMA mapping correction that squashes sporadic file system I/O errors reported under heavy I/O workloads. Microsoft’s WSL team described the changes as “essential for shared-folder reliability,” signaling that the 6.18.35.1 kernel is more than a version bump—it’s a targeted stability upgrade.

What’s Inside WSL Kernel 6.18.35.1

The kernel package carries two primary fixes alongside the mainline Linux 6.18.35 merge:

  • virtio-fs oversized DAX write patch: Addresses an off-by-one calculation in the Direct Access (DAX) write path that would corrupt or outright reject writes that straddled a 4 GB alignment boundary. Before the fix, a write request that crossed the 0x1_0000_0000 byte mark could trigger an EIO error or silently drop data.
  • DMA mapping fix for large I/O buffers: Resolves a page-address arithmetic bug in the virtio-fs DMA mapping layer that could cause scatter-gather lists to be assembled incorrectly, leading to file system I/O failures under sustained read/write loads.

Both issues live inside the virtio-fs driver, the 9P-over-virtio filesystem that underpins /mnt/c and other Plan 9 mounts in WSL2. Because the driver is compiled directly into the WSL2 kernel, Microsoft distributes the fixes as a complete kernel image rather than as a live patch.

Upstream Linux 6.18.35 itself brings a collection of ARM64 memory-management improvements, scheduler tweaks, and filesystem maintenance patches. Most WSL users will notice these only as a general smoothing of background activity, but the integration means WSL2 stays current with the Linux Foundation’s long-term support cadence.

Why a 4 GB Boundary Matters Inside a VM

Virtual filesystem bridges such as virtio-fs use a ring buffer between the host and guest to shuttle file data. DAX (direct access) mode maps the host’s page cache directly into the guest’s address space, reducing copies but requiring exact alignment with the host’s memory management unit (MMU) page tables.

When a write request spans a 4 GB virtual address offset, the kernel must split the operation across two separate page-table entries. A one-byte miscalculation in the range checks inside virtio_fs_dax_write would clip the request at the boundary, effectively telling the guest that 4 GB was a hard write limit per call. The application sees a short write or an I/O error, neither of which is obvious to debug.

“I was moving a 5.6 GB tar.gz file from /mnt/c to a container’s overlayfs and kept getting ‘No space left on device’ even though the disk had 200 GB free,” said one anonymous developer in a GitHub issue thread from April 2026. The error vanished after the user resorted to splitting the file with split or dropping DAX. Microsoft’s kernel team later confirmed the root cause was the virtio-fs boundary check.

The problem was particularly acute for workloads that touch files slightly larger than 4 GB—Unreal Engine asset packs, SQLite databases used for offline analytics, Python pandas dataframes serialized with to_parquet(), and Docker layers that cross the 4 GB threshold during docker build.

DMA Mapping Fix: The I/O Error You Couldn’t Reproduce

The second fix targets a subtler bug. virtio-fs can operate in either DAX or non-DAX mode. Under non-DAX, each read and write goes through the kernel’s DMA API, which creates scatter-gather lists describing the physical pages that back a virtual buffer. When a buffer spans multiple pages, the DMA mapping code must compute the offset and length for each scatter-gather entry.

Prior to the 6.18.35.1 kernel, an off-by-one in the page count calculation could cause the last entry in the scatter-gather list to point past the end of the buffer. The hypervisor would then reject the I/O request, producing a cryptic “virtio_fs: dma mapping failed” trace in the guest’s dmesg. Because the failure depended on the exact layout of physical memory at the time of the request, users reported it as intermittent—sometimes a file copy would succeed, sometimes it would fail.

Data scientists running heavy rclone syncs between OneDrive and WSL2 hit this regularly. A typical report described a 500 GB directory copy failing at a random point after 100–200 GB, with no consistent file size or type. The DMA fix eliminates the pointer overshoot, making non-DAX writes deterministic again.

Real-World Developer Impact

The fixes land at a time when WSL2 is transitioning from a convenience tool to a primary development environment. Microsoft’s own telemetry from Windows 11 shows that in May 2026, 58% of WSL2 sessions lasted longer than four hours, and 22% involved direct disk operations on /mnt/c or other DrvFs mounts. That’s a significant portion of users who regularly exercise the virtio-fs path.

Container Builds Stop Breaking

Docker Desktop with the WSL2 backend uses virtio-fs to share the host Windows filesystem with the Docker engine. When building images with ADD or COPY instructions pulling files larger than 4 GB, the old kernel would either truncate the source or fail midway through layer creation. Developers resorted to .dockerignore hacks or multi-stage builds that split large files into chunks.

With the fix, a docker build --memory=8g can copy a 6.2 GB SQL Server backup file without intervention. One verified test from the WSL community showed a 24-minute image-build pipeline that previously required manual file splitting completing in under eight minutes after the kernel update.

Data Pipelines Stop Spitting Errors

Python and R workflows that read and write Parquet, HDF5, or Arrow files often generate multi-gigabyte files. Data engineers working on Windows laptops with CUDA-enabled WSL2 environments were seeing “OSError: [Errno 5] Input/output error” during pandas.to_parquet() when the file exceeded 4 GB. The errors vanished when they moved the output to a native ext4 path inside the VM, confirming the virtio-fs path was at fault.

The 6.18.35.1 kernel allows those pipelines to run unmodified, keeping data inside the projected Windows filesystem where automation tools can pick it up without a second copy step.

Unreal Engine and Game Development

Game studios that adopted WSL2 for build automation hit the boundary when packaging game assets. Unreal Engine’s .pak files frequently exceed 4 GB, and automated builds that mount source code from a Windows drive would fail with truncated paks. Several studio build engineers reported that the only previous workaround was to maintain separate Perforce workspaces inside the virtual disk, which doubled storage consumption and complicated CI. The kernel patch eliminates the need for that duplication.

Performance Side-Effects

While the fixes primarily target correctness, they also reduce I/O jitter. The virtio-fs driver now correctly splits DAX writes at page boundaries without extra bounce-buffer copies, which can improve throughput for streaming writes by 3–5% in benchmarks using fio with a 4 GB block size. The DMA mapping fix avoids retry loops that could add hundreds of milliseconds of latency to individual I/O operations under memory pressure.

Microsoft’s kernel changelog does not promise raw speed boosts, but anecdotal reports from the WSL GitHub Issues tracker note faster git clone operations from repositories with large packfiles, as the delta resolution no longer triggers the boundary bug.

How to Get the Update

Windows 11 users receive the new kernel via Windows Update. The WSL2 kernel package is versioned independently from the WSL MSI, so running wsl --update from an elevated command prompt fetches kernel 6.18.35.1 directly. After installation, a wsl --shutdown cycles all running distros onto the new kernel.

To verify the kernel version, run:

$ wsl cat /proc/version
Linux version 6.18.35.1-microsoft-standard-WSL2 (root@buildhost) (gcc ...) #1 SMP PREEMPT_DYNAMIC Tue Jun 9 14:22:00 UTC 2026

Users on Windows 10 22H2 or earlier may need to enable the “Receive updates for other Microsoft products” setting in Windows Update because the WSL kernel is distributed through the Microsoft Update service rather than the main Windows Update channel.

What This Signals for WSL2’s Future

The 6.18.35.1 release continues a pattern: WSL2 kernel updates now track upstream point releases within a few weeks, and Microsoft patches hypervisor-adjacent drivers with the same urgency it applies to Azure’s virtualized infrastructure. The virtio-fs driver, originally contributed by Red Hat and Fujitsu, has become a critical piece of WSL2’s architecture, and Microsoft’s willingness to upstream fixes and maintain a forked branch suggests the company views it as a long-term component rather than a stopgap.

For developers, the message is clear: Microsoft is paying attention to the boundary conditions that arise when Windows and Linux share a filesystem. The 4 GB bug was a silent data corruption risk hiding in plain sight. Squashing it removes one of the last reasons to avoid placing large working files on the Windows side of the fence.

The WSL2 project’s GitHub repository now lists the virtio-fs DAX write patch as “backported from Linux 6.19-rc1,” meaning the fix will eventually flow into all distros that ship a newer kernel. In the meantime, Windows users have it first. For anyone who ever saw EIO while copying a VM disk image across the Plan 9 mount, Kernel 6.18.35.1 is the update that makes the pain disappear.