Microsoft has shipped an emergency update for the Windows Subsystem for Linux 2 (WSL2), delivering kernel version 6.18.35.2 on June 19, 2026. The release addresses a timekeeping regression that was inadvertently introduced in last week's 6.18.35.1 update, which could cause inaccurate system time on x86-based systems. The single-patch fix corrects an improper model-specific register (MSR) read, restoring reliable clock behavior for WSL2 users.

The swift version bump—from 6.18.35.1 to 6.18.35.2—underscores the severity of the bug and Microsoft’s agility in patching it. The regression, though short-lived, had the potential to disrupt time-sensitive workloads running under WSL2, including database transactions, build systems, and any application relying on accurate timestamps.

Background: How WSL2 Manages Its Kernel

WSL2 operates using a lightweight virtual machine that runs a full Linux kernel managed by Microsoft. This kernel is built from a stable long-term support (LTS) tree but includes patches and backports tailored for the Windows virtualization environment. Microsoft regularly updates this kernel to incorporate security fixes, performance improvements, and hardware enablement, releasing versions through Windows Update or directly via GitHub.

The 6.18.35.x series likely corresponds to a stable Linux kernel baseline that Microsoft has adapted. While Microsoft does not always announce every minor update, changes can occasionally introduce regressions, especially in low-level hardware interaction code. The timekeeping subsystem is particularly sensitive because it relies on precise readings from the CPU’s time counters.

The Technical Lowdown: MSRs and Timekeeping

To understand the impact, consider how x86 CPUs provide time information. CPUs maintain a Time Stamp Counter (TSC) that increments at a constant rate, accessible via the rdmsr instruction targeting a specific model-specific register (MSR). Intel and AMD define hundreds of MSRs, with the TSC typically mapped to MSR_IA32_TSC (address 0x10). Linux’s timekeeping infrastructure uses this hardware counter as a primary clocksource, along with the High Precision Event Timer (HPET) or the ACPI Power Management Timer.

When the kernel misreads an MSR—by accidentally accessing a different register number—it may fetch irrelevant data, garbage, or a counter with a different granularity. This can cause the system clock to jump forward or backward, drift by several seconds per minute, or even stall. In virtualized environments like WSL2, the hypervisor (Hyper-V) provides a paravirtualized clock (hv_clocksource) to avoid direct MSR access, but the kernel still has fallback paths that interact with hardware timers. A bug in those paths can undermine timekeeping even when the paravirtualized clock is in use.

What Went Wrong in 6.18.35.1?

In the 6.18.35.1 release, a patch likely introduced an error where the kernel read time-related data from an incorrect MSR. Instead of fetching the TSC or a calibrated timer value, it may have obtained a status register, a power management counter, or an undefined location. The symptom: system time became unreliable. Commands like date could show sudden discrepancies, clock_gettime() calls returned inconsistent results, and timestamps in log files appeared out of order. WSL2’s clock normally syncs with the Windows host via the Hyper-V Time Synch service; a kernel-level timing error could break that synchronization, leading to divergence between the Linux guest clock and the host.

The regression was “quietly introduced,” meaning it likely passed through limited testing and surprised users who updated to 6.18.35.1. While Microsoft has not disclosed the exact MSR address that was misused, the bug’s confinement to x86 systems (as opposed to ARM64) confirms it was an x86-specific MSR issue. ARM CPUs use memory-mapped generic timers, not MSRs, and were therefore unaffected.

The Fix: One MSR Correction in 6.18.35.2

Kernel 6.18.35.2 contains exactly one fix: the offending MSR access has been corrected. The version number—a fourth-level increment—indicates a minimal, targeted patch. Microsoft engineers likely reverted or amended a line of code that incorrectly referenced an MSR address or misinterpreted a read result. This single change restores proper timekeeping by ensuring the kernel reads the intended register. The patch is considered low-risk because it reverses a recent regression, and the surrounding timekeeping logic remains well-tested.

Impact on Users

For many WSL2 users, the regression may have gone unnoticed, especially on systems where the paravirtualized clock masked the error. But those running time-sensitive workloads quickly noticed anomalies:

  • Databases: PostgreSQL, MySQL, and other databases depend on consistent timestamps for transaction ordering, replication, and crash recovery. Inaccurate time could corrupt write-ahead logs or lead to split-brain scenarios.
  • Build systems: Tools like Make and Ninja use file modification times to decide what to rebuild. Skewed clocks can cause unnecessary recompilation or, worse, skip necessary steps.
  • Logging and monitoring: Security incident investigation and performance tracing become unreliable when log entries bear incorrect timestamps.
  • Cryptographic protocols: Certificate validation, token expiration, and one-time password generation all rely on accurate time; drift can cause failures or security warnings.
  • Scientific and financial computing: Simulations and transaction ordering assume a monotonic, accurate clock; any deviation can invalidate results.

Thankfully, the regression existed for only about a week. Microsoft’s rapid response minimized the damage, but the incident highlights the importance of promptly applying security and stability updates.

How to Update to 6.18.35.2

WSL2 kernel updates are distributed via Windows Update and manual channels. To ensure you receive the fix, open a PowerShell or Command Prompt as Administrator and run:

wsl --update

If the update is not immediately detected, force a kernel refresh with:

wsl --update --kernel-force

After updating, verify the installed kernel version by running:

wsl --status

It should display Kernel version: 6.18.35.2. Restart all WSL2 instances to load the new kernel:

wsl --shutdown

You can also download the standalone kernel installer from the official WSL2 Linux Kernel releases page. Select the package for x86_64 and install it manually. For users on ARM64, no update is required, though installing the latest kernel is still recommended for other fixes.

Verifying Time Accuracy After the Update

Once updated, you can confirm that timekeeping behaves correctly. Inside a WSL2 terminal, run:

date

Compare the output to your Windows host clock. For a more rigorous check, use timedatectl or a simple loop that prints timestamps and checks for monotonicity. If you previously observed anomalies, they should now be resolved.

A History of WSL Kernel Updates

Microsoft’s cadence for WSL kernel updates has been irregular but responsive. Major feature releases often accompany Windows Insider Preview builds, while hotfixes like 6.18.35.2 appear as needed. Earlier kernels have had regressions in networking (e.g., VPN compatibility), filesystem performance, and GPU support. Each time, the ability to push a targeted fix within days has been crucial for the large WSL2 user base.

The WSL2 kernel is built from the same tree as the upstream Linux stable kernel, but with Microsoft-specific patches. The version number follows the pattern major.minor.patch.microsoft_revision. So 6.18.35.1 denotes the first Microsoft revision of upstream 6.18.35, and 6.18.35.2 is the second. This minor bump indicates a very small code change.

Community and Developer Response

The WSL2 community often detects regressions first, reporting issues on the WSL GitHub repository or the kernel repository. In this case, internal testing or early adopters may have caught the timekeeping problem quickly. Microsoft’s swift patch suggests that the bug was considered severe and that the fix was straightforward.

The incident reinforces the value of the WSL Insider program, where volunteers can test pre-release kernels. The more users participate, the sooner such regressions are caught before broad deployment.

Why This Matters for the Future of WSL2

WSL2 is a cornerstone of Microsoft’s developer ecosystem, powering everything from web development to AI training on Windows. Its hybrid architecture—a real Linux kernel running in a lightweight VM—requires meticulous maintenance. Every kernel update must navigate the complexities of Hyper-V enlightenment, host-guest file sharing, and hardware acceleration. A simple MSR error can cascade into system-wide time corruption, reminding us that low-level hardware abstraction remains a delicate craft.

Microsoft’s rapid release of 6.18.35.2 demonstrates a healthy DevOps pipeline: detect a regression, identify the root cause, test the fix, and ship it globally within days. This agility is essential for a tool that millions of developers rely on.

Conclusion

WSL2 kernel 6.18.35.2 is a critical hotfix that every x86 WSL2 user should apply. It corrects a timekeeping regression that could silently undermine data consistency and application reliability. The update process is straightforward, and the risk of regressing is extremely low. As WSL2 continues to evolve, such swift responses will be key to maintaining trust in this indispensable bridge between Windows and Linux.