A single Dell PowerEdge R7725 server, stuffed with 40 high-capacity NVMe SSDs, has calculated pi to 314 trillion digits—a new world record—in just 110 days, proving that when it comes to extreme-scale number crunching, storage bandwidth trumps raw CPU power. The run, completed by the team at StorageReview, upends the long-standing assumption that massive clusters are necessary for such feats and delivers a clear message to Windows users and IT pros: the architecture of your storage matters as much as your processor.

Inside the Record-Breaking Server

The machine at the heart of this milestone is a Dell PowerEdge R7725, a 2U server with a 40-bay Gen5 E3.S backplane. Two AMD EPYC 9965 processors, each packing 192 cores, provided 384 total cores of compute muscle. But the real star of the show was the storage array: 40 Micron 6550 Ion NVMe SSDs, each with 61.44 terabytes of capacity, for a total of roughly 2.5 petabytes. Of these, 34 drives were dedicated to y-cruncher’s scratch and swap files, while the remaining six formed a RAID10 volume to protect the final output.

Crucially, the server’s backplane connects each SSD directly to the CPU’s PCIe lanes—no shared switch fabric in between. This architectural detail allowed the system to push aggregate read/write speeds to an eye-watering 280 GB/s, a figure that StorageReview directly credits for making the record possible. The system was also fitted with a CoolIT AHx10 liquid cooling unit to keep the processors running at high clocks during the entire 110-day marathon.

Software-wise, the team used y-cruncher v0.8.6.9545 with the Chudnovsky algorithm on Ubuntu 24.04.2 LTS Server. They reserved a handful of cores for system tasks and meticulously tuned NUMA placement, filesystem parameters, and I/O scheduling to avoid stalls. The run consumed about 1,600 watts of power continuously, totaling 4,305 kWh over its lifetime—impressively efficient given the scale of the computation.

The Windows Connection: Why the Team Ditched Windows Server

In a move that will raise eyebrows among Windows administrators, StorageReview initially tested the setup on Windows Server but switched to Ubuntu after observing measurably better I/O stability and throughput. The team didn’t elaborate on specific Windows shortcomings, but the implication is clear: for massive, sustained streaming workloads, the Linux I/O stack currently holds an edge.

However, this isn’t a final verdict. Microsoft has been aggressively improving NVMe performance in recent releases. Windows Server 2025, now generally available, includes a native NVMe driver and significant optimizations in storage spaces. Whether a tuned Windows Server 2025 build could close the gap remains an open question—and one that enterprising engineers might now be tempted to test.

What the Pi Record Means for Everyday Power Users and IT Pros

For the typical Windows enthusiast or sysadmin, a 110-day pi calculation might seem like a distant curiosity. But the lessons from StorageReview’s run apply directly to real-world Windows workloads:

  • For power users building high-performance desktops: If you’re configuring a workstation for video editing, large-scale data analysis, or machine learning, don’t skimp on storage bandwidth. Direct-attached NVMe arrays can dramatically reduce processing times compared to even the fastest SATA SSDs or networked storage.
  • For IT pros managing servers: The direct-connect backplane design matters. When evaluating servers for I/O-intensive applications (database servers, large file servers, Hyper-V hosts with many VMs), look for platforms that avoid PCIe switch congestion. Dell’s 17th-generation PowerEdge are a prime example, but other vendors offer similar architectures.
  • For developers working with large datasets: The experiment underscores the value of local, high-bandwidth storage for scratch and intermediate files. Cloud instances with network-attached storage might seem convenient, but they can impose latency penalties that kill performance on streaming workloads.

The run also demonstrates that energy efficiency isn’t reserved for low-power chips. The entire server drew about 1,600 watts, totaling 4,305 kWh over 110 days—a fraction of what a multi-node cluster would consume for the same task. For organizations watching their power bills, a single well-configured server can be the greener choice.

The Backstory: From CPU Flexing to Storage Stress Tests

Computing pi to ever-larger digit counts started as a way to show off floating-point performance. In the early 2000s, records fell as CPU clock speeds soared. But as the numbers grew into the trillions, the challenge shifted. Today’s multi-precision algorithms, like Chudnovsky used by y-cruncher, generate enormous intermediate files that must be read and written continuously. The working set can exceed main memory by orders of magnitude, forcing the system to treat SSDs as an extended scratchpad.

This is how a record that once belonged to supercomputers and cloud giants fell to a single server. Google’s 100-trillion-digit run in 2022 tapped cloud instances, while Linus Media Group and Kioxia used a Weka cluster to hit 300 trillion digits earlier this year. StorageReview’s 314-trillion run, by contrast, proves that with enough local NVMe bandwidth and careful tuning, a single node can outperform distributed systems for this class of problem.

How to Apply These Lessons to Your Own Hardware

If you’re planning a long-running, I/O-intensive project on Windows, here are practical steps inspired by the record run:

  1. Choose hardware with direct PCIe lanes to storage bays. Avoid backplane designs that share a PCIe switch if you need maximum aggregate bandwidth. Research server specs carefully—Dell’s latest PowerEdge servers, for instance, offer this feature.
  2. Equip your system with high-endurance NVMe SSDs. Enterprise drives like the Micron 6550 Ion are built for heavy writes. Even in consumer or prosumer setups, look for SSDs with high TBW (terabytes written) ratings.
  3. Invest in cooling. Sustained high-performance computing generates heat. Liquid cooling, as used in this record, ensures consistent clock speeds. For desktop builds, a robust AIO cooler or custom loop can prevent thermal throttling during long renders or data processing tasks.
  4. Tune your operating system for streaming I/O. On Windows, consider the following: enable write caching, adjust the I/O priority of your application, use large NTFS allocation units, and keep drivers and firmware up to date. While StorageReview favored Linux, a well-optimized Windows Server 2025 installation might compete—especially if you leverage Storage Spaces Direct with NVMe caching on a local node.
  5. Monitor drive health meticulously. The record run wrote over 7 petabytes to each SSD. Use tools like CrystalDiskInfo or Windows Admin Center to watch for wear and set up alerts. Keep spare drives on hand.
  6. Design for failure. The team ran their scratch array as a simple JBOD, accepting the risk of data loss to maximize throughput. For production workloads, implement redundancy at the application level or use RAID for critical data. Test your recovery procedure before starting.

What Comes Next

StorageReview’s record likely won’t stand for long. The pi computation community is already buzzing with ideas for pushing past 400 trillion digits using similar single-node designs or refined distributed approaches. Meanwhile, hardware vendors are taking notes: expect future server backplanes to adopt direct-connect architectures more widely, and SSD manufacturers to improve endurance for streaming workloads.

On the software side, the Windows-Linux performance gap for extreme I/O is now firmly in the spotlight. Microsoft’s NVMe improvements in Windows Server 2025 and Windows 11 (with DirectStorage) suggest the company isn’t standing still. A head-to-head comparison on identical hardware could be the next great benchmark battle.

For Windows users, the key takeaway is that storage is no longer the slow companion to the CPU—it’s the foundation. Whether you’re chasing world records or just trying to speed up your daily workflow, the lesson from this incredible pi run is simple: feed your processor data fast enough, and it will do amazing things.