Ubuntu 25.10 Leads in Multi-Threaded Ryzen 9 9950X Benchmarks vs Windows 11 25H2

Microsoft’s latest preview releases reveal a clear — and continuing — pattern: on identical high-end hardware, Ubuntu 25.10 is holding or extending Linux’s multi-threaded lead while Windows 11 25H2 remains highly competitive in single-threaded and platform-specific workloads, particularly where proprietary drivers or Windows-only APIs are involved.

Background​

The headline stems from a fresh set of side-by-side CPU benchmarks run on the same AMD Ryzen 9 9950X desktop hardware using clean OS installs and stock settings. Phoronix’s first-look testing compares Microsoft’s Windows 11 25H2 (available in preview channels ahead of the public rollout) against Canonical’s Ubuntu 25.10 development snapshots. The tests repeat the methodology Phoronix used in earlier Ryzen 9 9950X comparisons and offer immediate insight into how both vendor stacks behave on the newest Zen 5 silicon. (phoronix.com)
Windows 11 version 25H2 is reaching testers via Microsoft’s Insider channels before a general release planned for this autumn; Microsoft describes 25H2 as an enablement/servicing update that shares a servicing branch with 24H2, focusing on incremental improvements and enterprise management controls rather than sweeping new capabilities. (windowscentral.com, blogs.windows.com)
Ubuntu 25.10 represents Canonical’s interim release with newer toolchains, kernel updates, and compiler versions (GCC 15 series, Linux 6.16/6.17 variants in daily builds), making it a natural test target for cross-OS performance comparisons on modern CPUs. Phoronix’s snapshot testing of Ubuntu 25.10 is explicitly a “first look” during development. (phoronix.com)

---

Test platform and methodology​

Hardware and system configuration​

Phoronix’s Windows 11 25H2 vs. Ubuntu 25.10 comparison used the following notable configuration (clean installs, default performance/power defaults on each OS):

• CPU: AMD Ryzen 9 9950X (16 cores / 32 threads) at stock frequencies.
• Memory: 2 × 16 GB DDR5-6000.
• Storage: 1 TB Crucial T705 PCIe 5 NVMe SSD (CT1000T705SSD3).
• GPU (present but not the primary focus): AMD Radeon RX 9070.
• Clean OS installs and stock settings were used for parity; Windows tests used the 25H2 preview/release-preview channel and Ubuntu was tested from its daily/development 25.10 snapshots. (phoronix.com, openbenchmarking.org)

Benchmarks and measurement approach​

Phoronix ran an array of cross-platform CPU-focused tests — synthetics, real-world producer workloads, compression, encoding, and rendering tests — selecting binaries available for both Windows and Linux where possible to avoid compiler/toolchain bias. The goal was to compare out-of-the-box behavior rather than maximize each OS via custom tuning; that approach intentionally reflects what a typical enthusiast or creator would see when switching systems. OpenBenchmarking logs back up many of these runs, providing reproducible result traces. (phoronix.com, openbenchmarking.org)
Key points about the methodology:

• Clean installs for every OS iteration to avoid carryover configuration differences.
• Default OS power/performance settings to reflect “real world” usage.
• Emphasis on CPU-bound workloads (rendering, compression, encoding), not GPU gaming performance, which Phoronix reserved for a separate analysis.

---

What the first benchmarks show — executive summary​

• Linux (Ubuntu 25.10) continues to show an advantage in heavily multi-threaded and CPU-bound content-creation tasks (Blender renders, many video-encoding paths, some AI/ML inference workloads running on CPU). Where Linux wins, margins can be meaningful for time-sensitive production work. (phoronix.com, openbenchmarking.org)
• Windows 11 25H2 holds or improves upon Windows’ strengths in certain single-threaded tasks and workloads that depend on Windows-specific drivers or libraries. Because 25H2 is built as an enablement package on the same servicing branch as 24H2, its performance story is incremental rather than transformative — but tweaks to driver handling, scheduler decisions, or telemetry/service behavior can still change the real-world numbers you’ll see. (blogs.windows.com, windowscentral.com)
• On the geometric-mean and broad cross-section of tests, the raw picture shows Linux’s out-of-the-box performance often equal to or better than Windows on the same Ryzen hardware — a continuation of earlier discrepancies reported for Zen 5 chips. Independent data-collection portals (OpenBenchmarking) show the same trend in reproducible runs. (openbenchmarking.org, phoronix.com)

---

Deep dive: workload-by-workload analysis​

Multi-threaded rendering and producer workloads​

• Blender CPU renders, multiple open-source renderers, and many multi-threaded production tasks consistently favored Ubuntu in Phoronix’s runs. The combination of kernel scheduler choices, default CPU frequency governor behavior, and compiler versions (GCC 15 in Ubuntu 25.10 daily builds) contributes to better scale across cores in many of these tests. For creators rendering long scenes, a 5–15% turnaround in render time can translate into significant productivity gains. (phoronix.com)
• Where proprietary renderers (V-Ray, Indigo) are used, results were mixed: some Windows-native binaries still performed well on Windows, but Linux often matched or beat Windows when cross-platform builds were available and running on the latest compiler/kernel stacks. This suggests the advantage is not a simple “Windows vs. Linux” binary but a nuanced interplay between software build choices and OS-level scheduler/power decisions. (phoronix.com)

Video encoding, compression, and IO-heavy workloads​

• Several H.265/AV1 encoder paths and compression tools scaled more effectively on Ubuntu in these first-look tests. Differences here are often driven by how the OS schedules threads, handles memory bandwidth, and interacts with CPU frequency governors. Ubuntu’s newer kernel and userland toolchain in 25.10 can unlock compiler optimizations and syscall paths that favor high-throughput multi-core tasks. (phoronix.com)
• That said, Windows sometimes led on specific per-frame or single-file encodes where the Windows build of an encoder used a differently tuned runtime. This is why cross-platform parity matters: identical binaries reduce one major source of variance. (phoronix.com)

Synthetic single-threaded and mixed workloads​

• Single-threaded or lightly-threaded benchmarks (some synthetic CPU tests, older game engines, single-core cryptography/cryptohashing tests) still often nudge Windows ahead or tie the platforms. Windows’ scheduler and per-thread latency behavior remain strong for these workloads. (phoronix.com)
• Mixed workloads (part IO-bound, part CPU) depend heavily on driver maturity and file-system behavior. Windows’ NTFS and Microsoft’s driver stack can offer advantages in certain IO patterns, whereas Linux’s ext4/XFS stacks plus kernel optimizations can be superior in others. Users should match the OS to the workload rather than expect a single winner overall. (phoronix.com, openbenchmarking.org)

---

Why these differences keep appearing​

• Kernel scheduler and default governors: Linux distributions can expose lower-level CPU frequency/power controls and often ship newer kernel releases sooner than Windows gets equivalent low-level tuning. The result: more aggressive or more suitable scaling of Zen 5 cores in multi-thread scenarios on Linux. (phoronix.com)
• Toolchain and compiler versions: Ubuntu 25.10’s use of GCC 15 (versus older compilers in older Linux or Windows toolchains) can produce code generation that extracts more parallelism and better vectorization. This compound effect matters for CPU-bound workloads. (phoronix.com)
• Driver ecosystems: Windows tends to get vendor-tested proprietary drivers (particularly GPU drivers) that are optimized for gaming and certain GPU-accelerated paths. Linux’s open-source drivers (Mesa/RADV for AMD) have matured rapidly and in some CPU-bound workloads — especially where GPU isn’t the limiting factor — Linux’s lighter system overhead becomes decisive. NotebookCheck and other independent outlets have noted the same performance deltas in recent retests. (notebookcheck.net, phoronix.com)
• OS defaults and background services: Windows’ telemetry, antivirus, and virtualization-based security features are often enabled by default and can consume cycles that affect peak throughput; Linux distributions frequently ship with leaner defaults for workstation use. That said, enterprise Windows installs or power-user customizations can mitigate many of those overheads. (openbenchmarking.org, phoronix.com)

---

Practical takeaways for users and systems builders​

• For content creators and workstation users whose workloads are CPU-bound and heavily parallel (Blender, large video batch encodes, CPU-based data science workloads), Ubuntu 25.10 (or other modern Linux distros) is a compelling option for maximizing throughput without changing hardware. The first-look numbers show measurable gains in render and encoding time on the Ryzen 9 9950X. (phoronix.com)
• For gamers, software that relies on Windows-only APIs, or users who need vendor-specific GPU and NPU features, Windows 11 25H2 remains the practical choice. The Windows driver ecosystem and Windows-specific optimizations still give an advantage in many game and platform-locked AI scenarios. (blogs.windows.com, phoronix.com)
• For hybrid workflows (development on Linux but testing or deploying on Windows, or vice versa), dual-boot or containerized workflows (WSL2, VMs, or reproducible Docker images) allow teams to leverage the best of both worlds: Linux for raw compute throughput; Windows for platform compatibility. OpenBenchmarking’s reproducible runs are a useful starting point for enterprises wishing to validate the same on their hardware. (openbenchmarking.org)

---

Risks, limitations, and caveats​

1. Test scope and reproducibility: these are first-look benchmarks. Ubuntu 25.10 was tested from daily/development snapshots and Windows 11 25H2 was run from preview channels — both could change before final public release. Treat the numbers as a snapshot, not the final verdict. Phoronix explicitly labels these tests as preliminary. (phoronix.com, blogs.windows.com)
2. Driver and vendor updates matter: small driver or microcode updates can flip some results. The OS vendors and hardware partners frequently push fixes that materially alter performance. NotebookCheck and other testing portals have shown reproducible gains after BIOS/driver updates in previous Zen 5 comparisons. Cross-check before making purchasing decisions. (notebookcheck.net)
3. Default OS settings influence outcomes: Windows’ virtualization-based security and background services are on by default in many builds and can affect performance measurements. The Phoronix methodology leaned toward out-of-box settings — which represents typical consumer experience but may not reflect an optimized production configuration. (phoronix.com)
4. Workload-specific behavior: not every application maps cleanly to one OS’s strengths. Some proprietary applications are tuned for Windows; others (open-source, HPC, many AI toolchains) often find the Linux environment friendlier. Validate using your own workloads. (phoronix.com)

---

Recommendations for enthusiasts and professionals​

• If you run long, CPU-heavy production tasks (multi-hour renders, batch encoding, CPU-only AI inference), run a pilot: clone your workload onto Ubuntu 25.10 daily or a recent LTS with updated kernels and toolchains, and measure the wall-clock gains. Even modest percent gains multiply across long workloads. (phoronix.com)
• If you’re a gamer or rely on Windows-exclusive applications, stay on Windows 11 25H2 or 24H2 and keep drivers current. 25H2 arrives as an enablement package — useful for managing rollouts and enterprise control — but it is not a feature-overhaul, so performance tuning will still rely on driver and firmware updates. (windowscentral.com, blogs.windows.com)
• For mixed environments, consider hybrid approaches:
  • Use Linux VMs or dedicated Linux workstations for rendering/CI pipelines.
  • Keep Windows for gaming and proprietary app testing.
  • Use cross-platform CI (container builds, reproducible toolchains) to avoid surprise deltas between developer and production environments. (openbenchmarking.org)

---

What this means for AMD, Microsoft, and Canonical​

• The pattern reinforces a long-term reality: hardware performance is a joint outcome of silicon, firmware, drivers, toolchains, and OS-level defaults. No vendor wins solely by shipping fast silicon; software stacks and partnerships matter. Phoronix’s repeated comparisons show that the Linux stack (especially when paired with newer kernels and compilers) can quickly translate new architectural improvements into measurable gains. (phoronix.com)
• For Microsoft, 25H2’s preview status and enablement-package delivery model means much of the platform’s competitive work will come from driver vendors and incremental fixes rather than a monolithic OS uplift. Enterprises should plan deployments accordingly. (blogs.windows.com)
• For Canonical and the broader Linux ecosystem, Ubuntu 25.10’s updated toolchain and kernel cadence shows the upside of shipping modern software stacks quickly; this is beneficial for early adopters and workstation-focused users who need maximum throughput. (phoronix.com)

---

Conclusion​

These first benchmarks are less a proclamation of a permanent winner than a practical reminder: on modern AMD Zen 5 hardware like the Ryzen 9 9950X, Ubuntu 25.10’s updated kernel and toolchain can unlock meaningful multi-threaded CPU performance improvements out of the box, while Windows 11 25H2 remains the platform of choice for workloads locked to Windows APIs, specialized driver paths, or gaming.
Readers should treat the results as an actionable signal, not a universal prescription: if your day-to-day is dominated by heavy CPU rendering, a short pilot on Ubuntu 25.10 is warranted. If your workflow depends on Windows-only software, 25H2 should remain your focus — and keep drivers and firmware patched.
Phoronix’s first-look article and the associated OpenBenchmarking logs are excellent starting points for anyone building a decision matrix, and they underscore an enduring truth: real-world performance is a system story, not a chip story. (phoronix.com, openbenchmarking.org)

---

---

Source: Phoronix First Benchmarks Of Windows 11 25H2 vs. Ubuntu 25.10 On AMD Ryzen 9 9950X - Phoronix

 

[ChatGPT]

A fresh round of cross‑platform testing shows Ubuntu 25.10 pulling ahead of Windows 11 (version 25H2, preview) in heavily multi‑threaded workloads on AMD’s Ryzen 9 9950X, underscoring persistent differences in how Linux and Windows extract performance from modern Zen‑5 silicon. (phoronix.com)

Background​

The test platform at the center of this comparison is AMD’s Ryzen 9 9950X — a 16‑core, 32‑thread Zen‑5 desktop processor designed for high‑throughput workstation and creator workloads. AMD’s product pages and independent hardware databases list the chip at 16 cores / 32 threads with boost clocks up to 5.7 GHz and a 170W TDP, making it a fitting candidate for CPU‑bound rendering and encoding tests. (shop-us-en.amd.com, techpowerup.com)
Phoronix performed side‑by‑side benchmarking of Windows 11 version 25H2 (preview builds) and daily/development snapshots of Ubuntu 25.10, running clean installs on the same hardware and focusing on CPU‑centric real‑world workloads: Blender renders, multi‑threaded encoders, compression, and scientific/synthetic tests. Phoronix explicitly framed the results as a “first‑look” snapshot rather than a final verdict, and many of the raw runs were made reproducible through OpenBenchmarking logs. (phoronix.com, openbenchmarking.org)
Windows 11 version 25H2 is being distributed as an enablement package that sits on the same servicing branch as 24H2; Microsoft’s Insider channels made preview builds available before the public rollout. This 25H2 update is deliberately incremental — focused on lifecycle and manageability changes rather than sweeping new kernel‑level optimizations — which provides context for why any large performance delta would more likely arise from kernel/toolchain differences than from a dramatic Windows architectural shift. (windowscentral.com, learn.microsoft.com)

---

What the benchmarks measured​

Test focus and methodology​

Phoronix prioritized CPU‑bound, cross‑platform workloads and aimed to minimize bias by running binaries available on both platforms where possible. The intent was to show out‑of‑the‑box behavior under default settings rather than perform extreme, OS‑specific tuning. Hardware was matched across runs (same CPU, memory configuration, NVMe storage, and an AMD GPU present but not central to the CPU comparisons). The test suite included Blender CPU renders, Kvazaar/FFmpeg encoder runs, ASTC texture compression, 7‑Zip, and other producer‑oriented tasks used by creators and engineers. OpenBenchmarking entries provide run details for reproducibility. (openbenchmarking.org)

Key numerical takeaways​

• Ubuntu 25.10 often outperformed Windows 11 25H2 in multi‑threaded rendering and batch encoding tasks, with some workload‑level leads reported in the single‑digits and up to roughly 10–15% in the Phoronix snapshot runs. (phoronix.com)
• Windows retained an edge or parity in many single‑threaded or lightly threaded tests and in platform‑specific scenarios where Windows binaries or drivers were particularly well‑tuned. (phoronix.com)
• The geometric mean across a broad selection of tests historically favored Linux in aggregate throughput on Zen‑family processors — a pattern Phoronix observed earlier with Ubuntu 24.04 vs. Windows 11 — and the 25.10 preview figures continue that trend in the new snapshot comparisons. (phoronix.com)

---

Why Ubuntu 25.10 can show an advantage​

Kernel, governors, and scheduler choices​

Ubuntu 25.10’s development cycle is bringing newer upstream kernels (targeting Linux 6.16/6.17 in daily builds) and an updated power management stack. Linux distributions typically integrate recent kernel releases faster than Windows can incorporate equivalent low‑level changes, allowing the Linux stack to expose more aggressive or more suitable frequency‑scaling and scheduling behaviors for some workloads. These default differences — the Linux CPU governor, scheduler tunables, and how the kernel handles high‑corecount scaling — can produce measurable advantages for extended, parallelized workloads. (phoronix.com)

Toolchain and compiler impact​

Ubuntu 25.10’s move to GCC 15 and updated toolchains can improve code generation, vectorization, and optimization for modern instruction sets. When workloads use native builds compiled with newer compilers, those builds can extract more parallel throughput from a given core/thread configuration. Phoronix notes that toolchain and compiler differences are part of the compound effect that produces performance deltas in CPU‑bound scenarios. (phoronix.com)

Leaner defaults for creator workloads​

Default services, telemetry, and virtualization‑based security features in Windows can consume system resources under stock configurations. Phoronix’s methodology favored out‑of‑the‑box settings, which tends to show Linux’s leaner defaults for workstation images. While enterprise Windows deployments can be tuned, the “default experience” comparison favors the distribution shipping model that quickly adopts newer kernels and compilers.

---

Where Windows still wins​

Single‑threaded and platform‑specific performance​

Windows 11 retained strength in single‑threaded benchmarks and some platform‑specific workloads, especially those where Windows‑native runtimes, drivers, or proprietary binaries are optimized. The Windows scheduler and per‑thread latency characteristics still provide consistent responsiveness for sequential tasks common in desktop productivity apps and many legacy workloads. (phoronix.com)

GPU and vendor driver maturity​

Although this particular Phoronix run de‑emphasized GPU‑bound tests, Windows generally benefits from vendor‑tested, proprietary driver stacks — especially for gaming, GPU acceleration, and certain AI/NPU pipelines. That driver maturity and the breadth of Windows‑only APIs remain strong arguments for keeping production desktops or studios on Windows where compatibility and certified paths matter.

---

Practical implications for creators, studios, and IT teams​

When to consider Ubuntu 25.10 (or modern Linux)​

• Large, CPU‑bound rendering farms and batch encoding pipelines — When jobs are long and highly parallel, a 5–15% throughput improvement on Linux can directly reduce render times and operating costs. Running a pilot and comparing wall‑clock times for real workloads is the pragmatic next step. (openbenchmarking.org)
• CI and developer build servers — Faster compile and test throughput from updated toolchains can shorten feedback loops in large codebases, especially when builds are CPU‑heavy. Newer kernels and GCC versions may yield measurable improvements. (phoronix.com)
• Environments where license and ecosystem allow Linux — For teams already standardized on open‑source stacks or where cross‑platform parity is achievable, switching or hybridizing to Linux for heavy compute tasks can be low friction.

When Windows is the right choice​

• Users needing Windows‑only applications (Adobe Creative Cloud workflows, proprietary studio pipelines, many off‑the‑shelf creative tools). Compatibility and vendor certification often outweigh CPU throughput differentials.
• Gaming, GPU accelerated workloads, and integrated vendor solutions — The Windows driver ecosystem, DirectX tooling, and vendor‑certified GPU stacks still make Windows the practical platform for many real‑time and GPU‑heavy tasks.
• Enterprise deployments with strict management, compliance, and lifecycle requirements — Windows 25H2 is an enablement package that refreshes support lifecycles and enterprise controls, which can be decisive for regulated industries. (windowscentral.com)

---

Limitations and reliability of these results​

Snapshot status and reproducibility​

Phoronix labeled these runs as first‑look and used pre‑release Windows 25H2 preview builds and Ubuntu 25.10 daily snapshots. That means kernel versions, driver updates, and even build toolchains could evolve before final releases. The OpenBenchmarking entries associated with the runs are helpful for reproducibility; enterprises should replicate tests on their exact hardware and workloads before making procurement or deployment decisions. (openbenchmarking.org)

Binary parity and toolchain variance​

Where exact cross‑platform binary parity is unavailable (commercial renderers that ship different runtime libraries on Windows vs. Linux), differences in build options or library versions can skew outcomes. Phoronix attempted to reduce this by using cross‑platform workloads where possible, but readers must treat per‑application results as workload‑dependent.

Firmware and driver volatility​

Microcode updates, BIOS revisions, and vendor driver hotfixes can flip individual test results. NotebookCheck and other outlets have documented cases where post‑release firmware and driver updates materially changed Zen‑family benchmarks; similar volatility is expected here. Always re‑test with the latest firmware/driver set you plan to deploy.

---

Deeper technical analysis​

Kernel scheduling and Zen 5 characteristics​

Zen‑family processors have shown sensitivity to scheduler and governor choices because of their wide core counts and aggressive turbo behavior. Linux’s ability to ship newer kernel code — with scheduler tweaks, p‑state/power management improvements, and architecture‑specific optimizations — can tip the balance for sustained multi‑threaded throughput. These differences are often subtle: frequency dwell times, per‑core turbo strategies, and how interrupts or background threads are handled can change how evenly a large core set is utilized over a long run. (phoronix.com)

Compiler‑level vectorization and code generation​

GCC 15 introduces code generation improvements and expanded auto‑vectorization heuristics that can produce tighter instruction streams on modern x86 microarchitectures. When workloads are compiled with newer compilers and tuned flags, they can more fully exploit SIMD paths and widen the performance gap relative to older toolchains. This isn’t an intrinsic “Linux advantage” — it’s a cadence advantage: many Linux distributions adopt newer toolchains sooner than the equivalent Windows buildpaths update their compilers and SDKs. (phoronix.com)

---

Actionable recommendations​

• Run a pilot: clone representative renders/encodes and execute them on both OSes using the same data sets and, where possible, identical binaries to isolate OS and scheduler effects. Use OpenBenchmarking‑style reproducible logs for traceability. (openbenchmarking.org)
• Check vendor support: confirm that the commercial applications and GPU/NPU accelerations your studio relies upon are supported and certified on Ubuntu 25.10 before designing replacements.
• Re‑test after updates: BIOS microcode, GPU drivers, and kernel point releases can change outcomes — revalidate after each major firmware or driver refresh.
• Consider hybrid deployments: use Linux for heavy batch compute and Windows for desktop endpoints and GPU‑accelerated workflows that require proprietary drivers or certified stacks. Containers, CI agents, and reproducible Docker images can help minimize parity issues.

---

Risks and caveats for enterprises​

• Support and certification: Large studios and regulated organizations may be unable to move core production tools from Windows due to vendor certifications, making the theoretical performance gains moot if ecosystem parity can’t be achieved.
• Management overhead: Running mixed OS fleets adds management overhead and complexity for patching, configuration management, and security posture — consider automation and orchestration tools before switching large numbers of machines. (windowscentral.com)
• Unverifiable future changes: Because Ubuntu 25.10 runs in development snapshots for these tests and Windows 25H2 is previewed as an enablement package, the final shipping behavior could change; treat the present numbers as directional rather than definitive.

---

The broader performance landscape​

This latest snapshot continues a multi‑year pattern: when distributions rapidly adopt newer kernels and toolchains, Linux tends to translate recent silicon advances into improved throughput for heavily parallel workloads sooner than Windows does. That pattern has shown up in past Zen‑family comparisons and is visible again in the 25.10 vs 25H2 snapshot results. However, the practical decision — Linux or Windows — remains workload‑centric, balancing raw throughput against application compatibility, driver maturity, and organizational constraints. (phoronix.com)

---

Conclusion​

Ubuntu 25.10’s early development snapshots demonstrate measurable advantages in multi‑threaded, CPU‑bound content‑creation tasks on the Ryzen 9 9950X, leveraging a newer kernel and toolchain cadence to extract more throughput in many real‑world producer workloads. Phoronix’s first‑look testing, corroborated by reproducible OpenBenchmarking traces, shows Linux’s continued edge in these scenarios while confirming that Windows 11 25H2 remains competitive — particularly in single‑threaded and platform‑specific tasks where Windows optimizations and proprietary driver stacks matter. (phoronix.com, openbenchmarking.org)
For professionals and IT decision‑makers, the practical takeaway is straightforward: treat these results as an invitation to test, not a mandate. If your pipelines are CPU‑heavy and can run on Linux, run a pilot with Ubuntu 25.10 (or a tuned modern kernel) and measure wall‑clock gains. If your workflows depend on Windows‑only applications, driver certifications, or vendor‑specific accelerators, Windows 11 25H2 remains the safer, enterprise‑friendly platform. Either way, these benchmarks provide a timely, data‑driven signal that OS choice still matters — and that small percentages in throughput can compound into meaningful savings at scale. (windowscentral.com)

---

Source: WebProNews Ubuntu 25.10 Beats Windows 11 in Multi-Threaded Benchmarks on Ryzen 9 9950X