Windows vs Mac for Claude Code: The Benchmark That Changed How I Work
I use Claude Code heavily - it's become central to how I work on Laravel contributions, building apps, and exploring codebases. I have two machines: a Ryzen 9 9950X3D desktop with 64GB RAM running Windows 11, and an M1 MacBook Pro with 16GB. The desktop has significantly more raw power, but something always felt off. The Mac felt snappier when running Claude Code.
To put the hardware gap in perspective, here are the Geekbench 6 scores. The "My" columns are from my actual machines (9950X3D result, M1 Pro result), and the "Typical" columns are published averages:
| Benchmark | Typical 9950X3D | My 9950X3D | My M1 Pro | Typical M1 | 9950X3D vs M1 Pro |
|---|---|---|---|---|---|
| Geekbench 6 Single-Core | ~3,200 | 3,380 | 2,254 | ~2,400 | 1.5x |
| Geekbench 6 Multi-Core | ~23,000 | 22,160 | 10,422 | ~7,700 | 2.1x |
The 9950X3D is roughly 2x faster in multi-core versus the M1 Pro I actually use. On paper, it should demolish the Mac at everything. That's what made the next part so surprising.
So I built a benchmark to find out why.
What I tested
Not synthetic CPU scores - the actual operations that happen hundreds of times during a Claude Code session:
- Process spawning - every Read, Grep, Glob, and Bash call spawns a new process
- PHP execution - running tests, artisan commands, composer
- Disk I/O - reading and writing thousands of small files (like vendor/)
- File search - ripgrep and git grep across the Laravel framework
- Git operations - status, log, diff, branch listing
- Node.js - JSON processing and startup (Claude Code's internals)
I ran the benchmark three ways: Windows with Git Bash (what I'd been using), WSL2 on the same machine, and the Mac.
The results
| Environment | Total Time |
|---|---|
| Windows Git Bash | 11.9 seconds |
| WSL2 (same PC) | 2.8 seconds |
| Mac M1 | 2.6 seconds |
The Windows PC - with a 16-core, 32-thread 9950X3D and 64GB of RAM - was 4.3x slower than the same hardware running through WSL.
The smoking gun: process spawning
The single biggest bottleneck was process creation. Claude Code shells out constantly - git, php, grep, find, node - sometimes hundreds of times in a single conversation. Here's what 50 PHP process spawns looked like:
| Environment | 50x PHP Spawn |
|---|---|
| Windows Git Bash | 3,244ms |
| WSL2 | 457ms |
| Mac M1 | 31ms |
That's not a typo. Windows was 100x slower than the Mac at spawning PHP processes, and 7x slower than WSL on the same CPU.
This isn't a CPU problem - it's fundamental to how Windows creates processes. Linux and macOS use fork(), which is nearly free because it shares the parent process's memory pages until they're modified. Windows uses CreateProcess(), which has to load DLLs, set up security tokens, and initialize the environment from scratch every time. Add the Herd .bat wrapper on top and each PHP invocation carries real overhead.
Git spawning showed the same pattern - 791ms on Git Bash, 36ms on WSL. That's a 22x difference.
Where WSL actually beats the Mac
Once I switched to WSL, the PC didn't just match the Mac - it won in several categories:
| Test | WSL | Mac M1 | Winner |
|---|---|---|---|
| Write 2000 files | 24ms | 215ms | WSL (9x) |
| Read 2000 files | 17ms | 50ms | WSL (3x) |
| 50x git spawn | 36ms | 371ms | WSL (10x) |
| 50x node spawn | 576ms | 1,575ms | WSL (2.7x) |
| Node JSON 50k | 76ms | 92ms | WSL |
| Composer validate | 105ms | N/A | - |
| PHPUnit (2 suites) | 123ms | N/A | - |
WSL's ext4 filesystem crushed APFS on small file operations. Git spawning was 10x faster. The 9950X3D's raw power finally showed through once the Windows overhead was removed.
The Mac still wins on raw PHP execution - 2ms vs 33ms for the workload test. ARM silicon is remarkably efficient at this. But PHP execution speed matters less for Claude Code since it's the process spawning, not the execution, that's the bottleneck.
The RAM advantage
This is the other half of the story. The M1 MacBook has 16GB. My desktop has 64GB.
While running the benchmark, I checked task manager. I had three Claude Code instances running alongside Chrome, Discord, Spotify, NVIDIA Broadcast, and Steam - using 20GB total with 41GB still free.
On the Mac, running three Claude Code sessions simultaneously would mean swapping to disk. On the PC, I'm at 33% utilisation. I could run 4-5 Claude Code sessions in parallel without thinking about it. For multi-repo work - fixing a framework PR in one terminal while building a feature in another and running tests in a third - that headroom matters.
What I changed
The bottleneck was never the hardware. It was Windows.
For those unfamiliar, WSL (Windows Subsystem for Linux) is a feature built into Windows that lets you run a full Linux environment directly on your machine - no virtual machine setup, no dual booting. You can access it from any terminal on Windows: open PowerShell, Windows Terminal, or even Git Bash and type wsl to drop into a Linux shell. From there, you get native Linux performance for all your CLI tools.
I now default to WSL for all CLI-heavy operations - not just git (which I was already doing for CRLF reasons). Tests, composer, file search, anything that involves repeated process spawns. The key detail: keep repos on WSL's native ext4 filesystem (~/Herd/framework), not on the mounted Windows drive (/mnt/c/...). The 9P filesystem bridge between Windows and WSL adds its own overhead.
I also updated Claude Code's persistent memory with recommendations based on these benchmarks - telling it to prefer WSL for all CLI-heavy operations on Windows. Now when I start a new session, Claude Code already knows to route commands through WSL where possible, without me having to remind it every time. It's a small thing, but it means the performance gains carry forward automatically across every future conversation.
Build your own benchmark
The benchmark script is portable - it auto-detects your OS, finds PHP/Composer/Node/ripgrep, and tests against a Laravel framework checkout if one exists. If you want to test your own setup:
git clone git@github.com:JoshSalway/dev-workflow-benchmark.git
cd dev-workflow-benchmark
bash dev-workflow-benchmark.sh
It saves results to a file, and there's a compare.sh script for side-by-side comparison with colour-coded output.
The takeaway
If you're a developer on Windows using Claude Code (or any tool that shells out frequently), and things feel slower than they should - try WSL. The CPU isn't the problem. Windows process creation is. WSL gives you Linux-native speeds on the same hardware, and if your machine has decent RAM, you get parallelism that a MacBook can't match.
My 9950X3D went from the slowest machine in this test to effectively tied for fastest - just by changing which shell I run things in.