Hubbry Logo
Prime95Prime95Main
Open search
Prime95
Community hub
Prime95
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Prime95
Prime95
Prime95
View on Wikipedia
from Wikipedia
Prime95
DeveloperGeorge Woltman
Initial release3 January 1996; 30 years ago (1996-01-03)
Stable release
30.19 build 20[1] / June 2, 2024; 20 months ago (2024-06-02)
Preview release
31.04 build 3[2] / January 4, 2026; 33 days ago (2026-01-04)
Written inASM, C
Operating systemMicrosoft Windows, macOS, Linux, FreeBSD
TypeMersenne prime finder / system stability tester
LicenseFreeware[3]
Websitemersenne.org Edit this on Wikidata

Prime95, also distributed as the command-line utility mprime for FreeBSD, Linux, and MacOS is a freeware application written by George Woltman. It is the official client of the Great Internet Mersenne Prime Search (GIMPS), a volunteer computing project dedicated to searching for Mersenne primes. It is also used in overclocking to test for system stability.[4]

Although most[5] of its source code is available, Prime95 is not free and open-source software because its end-user license agreement[3] states that if the software is used to find a prime qualifying for a bounty offered by the Electronic Frontier Foundation,[6] then that bounty will be claimed and distributed by GIMPS.

Finding Mersenne primes by volunteer computing

[edit]

Prime95 tests numbers for primality using the Fermat primality test (referred to internally as PRP, or "probable prime"). For much of its history, it used the Lucas–Lehmer primality test, but the availability of Lucas–Lehmer assignments was deprecated in April 2021[7] to increase search throughput. Specifically, to guard against faulty results, every Lucas–Lehmer test had to be performed twice in its entirety, while Fermat tests can be verified in a small fraction of their original run time using a proof generated during the test by Prime95. Current versions of Prime95 remain capable of Lucas–Lehmer testing for the purpose of double-checking existing Lucas–Lehmer results, and for fully verifying "probably prime" Fermat test results (which, unlike "prime" Lucas–Lehmer results, are not conclusive).

To reduce the number of full-length primality tests needed, Prime95 first checks numbers for trivial compositeness by attempting to find a small factor. As of 2024, test candidates are mainly filtered using Pollard's p − 1 algorithm. Trial division is implemented, but Prime95 is rarely used for that work in practice because it can be done much more efficiently using a GPU, due to the type of arithmetic involved. Finally, the elliptic-curve factorization method and Williams's p + 1 algorithm are implemented, but are considered not useful at modern GIMPS testing levels and mostly used in attempts to factor much smaller Mersenne numbers that have already undergone primality testing.

GIMPS has discovered 18 new Mersenne primes since its foundation in 1996, the first 17 of which using Prime95. The 18th and most recent, M136279841, was discovered in October 2024 using an Nvidia GPU, being the first GIMPS discovery to not have used Prime95 and its CPU computation.[8][9][10] 15 of the 17 primes discovered with Prime95 were the largest known prime number at the time of their respective discoveries, the exceptions being M37156667 and M42643801, which were discovered out of order from the larger M43112609.[11]

gwnum

[edit]

gwnum is the code for most mathematical operations in Prime95. It is written in hand-tuned assembly code for a number of microarchitectures. For large number modular multiplication it implements the irrational base discrete weighted transform in double precision, exploiting the oversized (compared to integer operations) floating-point capacity of x86 CPUs. It also implements polynomial multiplication for use in P-1 and ECM Stage 2.

gwnum is also used by other distributed computing projects such as PrimeGrid's PRST.

Use for stress testing

[edit]
Prime95 28.7 running a stress test on an Intel quad-core Windows 10 system

To maximize search throughput, most of Prime95's math library (gwnum) is written in hand-tuned assembly, which makes its system resource usage much greater than most other computer programs. Additionally, due to the high precision requirements of primality testing, the program is very sensitive to computation errors and proactively reports them. These factors make it a commonly used tool among overclockers to check the stability of a particular configuration.[4]

Prime95 has a built-in "torture test" (formerly "Self-Test") feature for this purpose. In this mode, it checks the results of stress testing against known-good results that comes with the program. As a result, any miscalculation is definitively spotted. The "small" and "medium" FFT modes have a memory access pattern that fits into the CPU's cache, making them ideal for placing maximal stress on the CPU cores. The "large" FFT mode needs to frequently access the RAM. As a result, it produces less stress on the CPU but is able to test the memory controller as well as the memory modules. There is also a "blend" mode that mixes these modes.[12]

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Prime95

View on Grokipedia
from Grokipedia
Prime95 is a application written by George Woltman that serves as the official client software for the (GIMPS), a project founded in 1996 to discover numbers of the form 2p−12^p - 1. Designed initially for volunteer participants to perform primality tests on large exponents using optimized assembly code on processors, it has evolved into a versatile tool that combines mathematical computation with hardware . While its primary goal remains contributing to GIMPS's efforts—which have identified the last 18 known Mersenne primes—Prime95 is widely used by overclockers and system builders to rigorously evaluate CPU and memory stability through intensive workloads like the Lucas-Lehmer test. The software's development began with GIMPS's inception, when Woltman created hand-tuned code to enable efficient searching on everyday computers, marking a pioneering use of for hunting. Early versions, released in 1996, targeted Intel systems and quickly gained traction among enthusiasts, leading to discoveries such as the 35th in 1996. Over time, Prime95 incorporated advanced features like multi-threading support, customizable torture test modes (e.g., Small FFTs for CPU-focused stress or Blend for combined CPU-RAM testing), and integration with the PrimeNet server for coordinated global efforts. A command-line variant, mprime, extends its availability to , , and other systems. Beyond prime searching, Prime95's reputation stems from its ability to push hardware to extremes, simulating real-world computational demands to detect or errors in overclocked setups. This dual-purpose design has made it a staple in the community, with ongoing updates ensuring compatibility with modern processors while maintaining its core focus on advancing mathematical discovery through collaborative science.

Development and History

Origins and Creator

Prime95 was developed by George Woltman, a computer programmer and mathematician, who began work on the software in late 1995 with the primary goal of enabling efficient searches for Mersenne primes using resources. Woltman's motivation stemmed from a desire to advance by creating accessible tools that could harness the growing power of personal computers for distributed prime hunting, particularly targeting the form 2p−12^p - 1 where pp is prime. This initiative was closely tied to the founding of the (GIMPS) project in January 1996, for which Prime95 served as the core client software. The initial version of Prime95, 1.0, was released in as a Windows application, marking the program's debut as a tool optimized for the era's consumer hardware. Designed from the outset for large-scale prime testing, it emphasized volunteer participation by allowing users to contribute idle CPU cycles without requiring specialized equipment. One of the key early challenges Woltman faced was optimizing the software for standard i386 processors prevalent in mid-1990s personal computers, as there were no readily available specialized mathematical libraries for high-precision arithmetic. To address this, he implemented hand-tuned assembly code for the computationally intensive operations, ensuring the program could perform effectively on everyday hardware while minimizing resource demands. This approach laid the foundation for Prime95's reputation as a robust tool for mathematical computing in distributed environments.

Release Timeline and Major Versions

Prime95 was initially released on January 3, 1996, as version 1.0, developed by George Woltman to facilitate the (GIMPS). Early development focused on optimizing Lucas-Lehmer primality testing, with version 2.0 in 1997 introducing multi-threading to better utilize multi-processor systems. Version 27, released in December 2012 with build 27.9, shifted to 64-bit architecture, enabling higher memory addressing and improved efficiency on contemporary hardware. In , version 28 introduced probabilistic prime (PRP) testing, allowing quicker identification of likely primes and reducing the need for resource-intensive full proofs in initial screening. Version 29, starting with builds in late , incorporated numerous bug fixes, deprecated obsolete FFT implementations to modernize the codebase, and enhanced error-checking mechanisms for greater reliability. support was introduced in version 29.8 (late 2018), with further optimizations in the version 30 series, which began in early 2020 and significantly accelerated computations on compatible CPUs. The latest stable release is version 30.19 build 20 from June 2024, with build 21 released in September 2024. This version includes faster ECM stage 2 processing when ample memory is available and automatic merging of configuration files for easier management. Although the core Prime95 executable remains closed-source under a custom , for the Windows, Linux, and other ports is publicly available for non-commercial use, while certain utility tools like configuration scripts are released under the GNU General Public License (GPL). These version milestones have been instrumental in Prime95's contributions to GIMPS, aiding discoveries such as the 51st known in 2018 and the 52nd known (2136279841−12^{136279841} - 1) on October 12, 2024.

Integration with GIMPS

The (GIMPS) is a collaborative project founded in 1996 by George Woltman to harness power in the search for , which are of the form 2p−12^p - 1 where pp is itself a prime number. Launched as one of the earliest large-scale volunteer efforts in , GIMPS coordinates participants worldwide to test enormous candidate numbers for primality, contributing to advancements in understanding prime distribution and record-breaking discoveries. Prime95 serves as the official and primary client software for GIMPS, enabling users to specific work assignments—typically ranges of exponents pp to test—from the project's central PrimeNet server and to upload the resulting data automatically. This integration allows Prime95 to function seamlessly within the GIMPS framework, where it performs the core computations on participants' personal computers, focusing on CPU-intensive tasks while minimizing manual intervention. Communication between Prime95 and the PrimeNet server occurs via the HTTP protocol, facilitating automated coordination of tasks such as assigning new exponents, reporting test outcomes hourly, and scheduling double-checking of previous results to confirm primality claims with high reliability. This server-client architecture ensures efficient distribution of workload and verification, preventing duplication and maintaining the integrity of the search. By 2025, GIMPS has engaged thousands of volunteers globally, with Prime95 handling the majority of CPU-based computations that drive the project's progress in testing billions of candidates. This scale underscores Prime95's pivotal role in enabling a decentralized yet coordinated effort that has sustained the hunt for Mersenne primes over nearly three decades.

Search Process and Assignments

Prime95 facilitates the search for Mersenne primes through various assignment types coordinated via the (GIMPS) project. These include first-time tests on new exponents using probabilistic prime (PRP) methods to identify potential candidates, double-checks of prior Lucas-Lehmer (LL) test results to verify reported residues, and advanced PRP trials on promising exponents to confirm probable primality before full verification. The operational workflow begins with Prime95 connecting to the PrimeNet server to download an assigned exponent based on user preferences for work type and computational capacity. Once downloaded, the software executes the appropriate test—such as an or PRP computation—on the Mersenne number 2^p - 1, where p is the exponent. Upon completion, Prime95 uploads the resulting residue or primality certificate back to PrimeNet, allowing the assignment to be marked as complete and enabling the next task to be queued. This cycle repeats for unproven exponents in ongoing ranges, with hourly progress reports ensuring seamless integration into the distributed search effort. A notable contribution occurred in 2018 when volunteer Patrick Laroche used Prime95 on an i5-4590T processor to discover the 51st known , 2^82,589,933 - 1, comprising 24,862,048 digits, which took about 17 days of computation on his hardware. This finding underscored Prime95's role in advancing GIMPS discoveries, with the primality proof taking 12 days on his hardware and the result independently verified using three different programs on three different hardware configurations. More recently, in October 2024, the 52nd known , 2^{136279841} - 1, was discovered through GIMPS, though using GPU-based computation, underscoring Prime95's continued importance for CPU-intensive tasks. To handle interruptions, Prime95 automatically saves progress every 30 minutes to intermediate files, such as those named pNNNNNNN or backup variants, enabling recovery from power failures, crashes, or user pauses. Upon restart, the program resumes from the last save point via the Test/Continue menu, minimizing lost work and ensuring reliable continuation of long-running assignments even after errors or system halts.

Stress Testing Capabilities

Purpose and Test Types

Prime95's primary purpose in stress testing is to simulate intensive computational loads on computer hardware, thereby identifying instabilities in components such as CPUs, RAM, and cooling systems. By leveraging the (FFT) algorithm originally developed for searches, the program pushes systems to their limits, revealing issues like overheating, faulty memory, or inadequate power delivery that might not surface under normal usage. This makes it particularly valuable for validating hardware stability before or after modifications like . The software offers several distinct test modes, each targeting different aspects of hardware performance. The Small FFTs mode focuses on stressing the CPU cores and onboard cache, using computations that fit entirely within the processor's cache to maximize heat generation and computational intensity without significant memory involvement. In contrast, the Large FFTs mode emphasizes and the CPU-RAM interface by employing larger data sets that require frequent access to main system , making it ideal for detecting issues in high-capacity RAM configurations. The Blend mode combines elements of both, cycling through a range of FFT sizes to provide a balanced assessment of CPU, cache, and RAM under varied loads, and is often recommended as the default for comprehensive system diagnostics. Additionally, a Custom mode allows users to specify allocation limits for targeted testing. Common usage scenarios include pre-overclocking validation to ensure safe operation at elevated speeds, troubleshooting system crashes or freezes during heavy workloads, and routine diagnostics on newly assembled or upgraded PCs. For optimal results, tests are typically run for extended periods, such as 24 hours or more, to catch intermittent faults. Output metrics primarily consist of error reports logged in a results.txt file, including rounding errors exceeding thresholds (e.g., "ROUND OFF > 0.40"), input-output sum mismatches (e.g., "SUMINP != SUMOUT"), or explicit "Torture Test failed" messages, which signal hardware instability requiring further investigation or correction. Successful completion without errors indicates robust system stability.

Configuration and Results Interpretation

To configure Prime95 for stress testing, users can launch the program and select "Just Stress Testing" from the initial menu, which skips prime search setup and focuses on the torture test. Within the torture test options, presets include Blend mode, which exercises both CPU and RAM using (FFT) sizes from 512K to 4M; Small FFTs, targeting CPU caches and floating-point units with smaller sizes like 8K to 64K; Large FFTs, emphasizing RAM with sizes up to 4096K or more; and Custom mode for manual FFT range selection. Alternatively, the command-line option prime95.exe -t directly starts the torture test without the GUI. For modern CPUs, consider adjusting AVX support in the local.txt file (e.g., adding CpuSupportsAVX=0) to moderate stress intensity if excessive heat is an issue. Runtime parameters allow customization of test behavior, such as the number of worker threads, which Prime95 automatically sets to match the system's logical CPU cores but can be adjusted via the "Worker Threads" or by editing the local.txt file (e.g., setting NumCPUs=4 for fewer threads). Stopping conditions include manual interruption via the "Test > Stop" or , or automated halting upon detecting the first error. The test runs continuously by default, saving progress every 30 minutes to resume if interrupted. Interpreting results involves monitoring the worker windows for output messages; a test completing millions of iterations with "No errors" confirms system stability under load. Errors are flagged as fatal when computations deviate from expected values, such as "FATAL ERROR: Rounding was 0.5, expected less than 0.4," which typically indicates RAM timing or voltage issues, while "Hardware failure detected" or consistent mismatches at varying spots point to CPU instability, overheating, or problems. Repeated errors in the same location may suggest a software issue, warranting a report to the developers. Best practices recommend running the torture test overnight or for 6-24 hours to uncover intermittent faults, starting with Blend mode for comprehensive coverage before isolating components. Combine Prime95 with dedicated RAM tools like MemTest86 for deeper analysis if rounding errors appear, and monitor temperatures using utilities such as HWMonitor to ensure they remain below the CPU's specified maximum safe temperature (typically 90-100°C, depending on the model; check manufacturer specifications). Always run at high priority (set via ) to maximize CPU utilization.

Technical Details

Algorithms and Optimizations

Prime95 employs the Lucas-Lehmer test as its primary for verifying the primality of Mersenne numbers of the form 2p−12^p - 1, where pp is prime. The test initializes a sequence with s0=4s_0 = 4 and si=(si−12−2)mod  (2p−1)s_i = (s_{i-1}^2 - 2) \mod (2^p - 1) for i=1i = 1 to p−2p-2; the Mersenne number is prime sp−2=0s_{p-2} = 0. This requires efficient computation of large squarings 2p−12^p - 1, which Prime95 optimizes to handle exponents up to millions, enabling the discovery of record-setting primes through the (GIMPS). For initial screening of candidates, Prime95 uses a (PRP) test to rapidly identify composites before committing to the costlier Lucas-Lehmer test. Since 2018, this has been implemented as an optimized Fermat-based PRP test tailored for Mersenne numbers, incorporating Gerbicz error checking to detect computational errors with high probability and thus ensure result reliability without redundant runs. Unlike traditional Miller-Rabin variants that rely on multiple witnesses for probabilistic assurance, this approach leverages the special structure of Mersenne numbers for efficiency, providing deterministic outcomes for exponents up to 2642^{64} through parameter selection that avoids pseudoprimes in the tested range. PRP results are further validated using compact proofs introduced in 2020, reducing verification costs by over 99%. The core of Prime95's computational efficiency lies in its custom (FFT) implementation for multiplying large integers during primality tests. It utilizes radix-2 and mixed-radix FFTs based on the irrational base discrete weighted transform (IBDWT), pioneered by Crandall and , which employs to accelerate convolutions while monitoring errors to maintain precision below 0.4 units in the last place. This avoids slower all-integer methods and achieves asymptotic of O(plog⁡plog⁡log⁡p)O(p \log p \log \log p) bit operations for exponent pp, with no zero-padding to minimize memory usage. The FFT kernels are hand-coded in assembly for x86 architectures, incorporating SIMD instructions such as SSE and AVX to vectorize operations across multiple data elements per cycle. Additional optimizations in Prime95 focus on hardware utilization and . The software supports multi-threading to distribute workloads across all available CPU cores, scaling performance nearly linearly on multi-core systems for both PRP and Lucas-Lehmer tasks. Assembly-level tuning for x86 ensures maximal instruction throughput, while user-configurable parameters allow adjustment for L1, L2, and L3 cache sizes, optimizing FFT block allocations to reduce cache misses and demands during iterative squarings. These enhancements collectively enable Prime95 to sustain high-throughput testing on commodity hardware, contributing to GIMPS's success in identifying the 18 most recent known Mersenne primes.

Platform Support and Performance

Prime95 primarily targets x86 and x64 architectures, with official binaries available for (32-bit and 64-bit versions supporting , 8, 7, Vista, and XP), where it provides a for configuration and monitoring. For (32-bit and 64-bit), (versions 12, 11, 10, 8, and 7 in both 32-bit and 64-bit), and macOS (command-line support on Intel-based systems running Mac OS X 10.9 or later), the software operates via the mprime command-line executable, often requiring compilation for custom setups. Support on macOS is limited, with legacy graphical versions available up to 29.8 build 7 for pre- systems and no native execution on (ARM64) hardware. The program is optimized for Intel and AMD CPUs, utilizing advanced instruction sets such as , AVX, AVX2, and to accelerate (FFT) operations central to its computations. Native GPU support is absent, directing users to specialized external applications like CUDALucas for GPUs or gpuOwL and clLucas for AMD GPUs to leverage graphics hardware for Mersenne prime testing tasks. In terms of performance, Prime95's efficiency is gauged by its ability to complete Lucas-Lehmer primality tests on Mersenne numbers, where an average requires approximately one month for a single test on typical exponents, though modern multi-core CPUs can process exponents exceeding 100 million bits in a of days by distributing workloads across cores. AVX-512 implementations, introduced in version 29.8, enhance overall throughput while increasing power demands. Despite its capabilities, Prime95 lacks optimizations for mobile or low-power devices, as its design prioritizes maximum CPU utilization, resulting in substantial power consumption and output that can exceed 200 watts on high-end systems during intensive tests. This makes it impractical for battery-constrained environments or systems without robust cooling, focusing instead on desktop and server-grade hardware for sustained operation.
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.