CEMPLLA version 1.5 has been Released

CEMPLLA version 1.5 has just been released.

CEMPLLA, an acronym for “CUDA-Enabled Mersenne Prime Lucas-Lehmer Assessment”, is a completely free, full-featured set of programs that work together to enable participants the opportunity to make history, and possibly win a substantial sum of money at the same time, by helping to discover the largest prime numbers ever recorded in history.

The thrust of the CEMPLLA effort is to win either or both of the two monetary awards currently being offered by the Electronic Freedom Foundation (the “EFF”); namely, the award for the discovery of the first one billion decimal digit prime number ($250,000), and the award for the discovery of the first one hundred million decimal digit prime number ($150,000). CEMPLLA participants who discover either of these stand to win a substantial percentage of the EFF’s monetary award for their efforts (details are fully explained in CEMPLLA’s documentation).

CEMPLLA is very easy to use, and is currently the only software in the world capable of discovering the first one billion decimal digit prime number. And it’s one of only two in the world capable of discovering the first one hundred million decimal digit prime number.

CEMPLLA works exclusively with NVidia brand GPU equipment to achieve its goals, so you must have at least one NVidia brand GPU installed on your machine(s) to use the software. However, because the goal of the CEMPLLA system is so computationally intensive, as a general rule you should have more than just one GPU board installed on your system to get any meaningful results.

Also, it only runs on Microsoft Windows 64-bit operating systems.

All of the details pertaining to what CEMPLLA is, does, and is trying to accomplish are contained in the CEMPLLA Install program’s extensive pop-up documentation. But you don’t have to install CEMPLLA to read any of it; installation is completely optional. And of course, if you do decide to install it, then decide later that it’s not for you, you can completely remove it at any time by using Control Panel’s “Programs and Features”.

The significant differences from earlier versions are as follows:

  • The minimum number of NVidia GPUs required to install CEMPLLA are now: 1
  • CEMPLLA no longer uses the Internet, so no Internet connection is required.
  • Documentation has been expanded and revised.
  • The “MPCG” trial factoring component has been completely removed.
  • A utility to control the Windows “GPU TDR” feature has been added.
  • CEMPLLA now creates an encrypted “log” file that chronicles the entire LLT.
  • A utility for viewing the contents of the aforementioned “log” file was added.
  • Myriad bug fixes were made, too numerous to enumerate.
  • Added some limited networking support (for group efforts).

To download CEMPLLA v1.5 (free of charge or obligation), go to:

[url]Dropbox - CEMPLLA v1.5 Install.zip - Simplify your life

Extensive CEMPLLA discussion is found on mersenneforum.com

The above comment by “SPWorley” is completely incorrect.

The “CEMPLLA discussion” he has linked to is completely obsolete, as it pertains solely to CEMPLLA version 1.0, a much earlier version, and one that was discontinued a long time ago, and is therefore no longer available. The majority of comments in that particular thread also pertain almost entirely to either the “MPCG” component of the old version, which was completely removed in the new version, or to baseless, self-serving accusations of wrongdoing levied against this author by know-nothing miscreants, the reading of which is a complete waste of time.

The new announcement pertains solely to CEMPLLA version 1.5.

At the current time, there is no ongoing thread pertaining to the new version. However, should there ever be one, you can be sure that it will not be on mersenneforum.com, as that site is maintained by GIMPS, or some subsidiary thereof, which neither the CEMPLLA effort, nor the author of CEMPLLA, is affiliated with in any way.

The forum is mersenneforum.org, not .com.

OP is mistaken about his software’s uniqueness. Mlucas, written by Ernst Mayer, is capable of testing billion-digit numbers (and 100M digit numbers as well). Source is available for Mlucas, but not for CEMPLLA.

Perhaps the CEMPLLA author could post benchmarks, e.g. what size FFT is used for a billion-digit test? How many seconds per iteration? Users interested in such prizes should choose the fastest-available software, and it’s not automatic that a CUDA package will be faster than Mlucas on CPU.

What license is CEMPLLA released under?

Hmmm. Let’s see the differences from the old version to the new version:

  • old version: blind ZIP file with a blind .EXE inside. New version: same.
  • old version: you have no idea what it is doing (Unless you are gullible enough to believe that what a bunch of words on some discussion thread say and what a blind ZIP downloaded from dropbox will do have anything in common). New version: same.

I think “baseless and self-serving” are perfect adjectives describing this author’s work in general - and this particular tool, specifically. Dunning-Kruger effect prevents the author from seeing the limitations of his tool, as well as his approach to disseminating it. And even that is a charitable opinion. The truth, for all we know, could be that there is a WannaCry knock-off inside the ZIP that you are invited to download or similar. Download it, by all means. Run it. Just don’t complain.

Does anyone have actual data? I’d like to know how fast it runs compared to the well-honed existing LL programs. I hope it generates residues so we can check if it’s working properly? I couldn’t find any documentation, just a windows PE and a few forum threads on the web.

As the author of the software, isn’t up to you to prove otherwise (Usually this would be done by being open source, etc., if you read the mersenneforum thread from the past version). Also here’s more of a knowledge testing question. One of the following is a modified LL test, the other is TF , is this statement true or false?



if true which one is which.


Apparently, not one of you even bothered to even run the Install program.

If I download an .exe from the internet, the first thing I do is run it through all of my virus and malware checkers. If it passes all of them, I feel comfortable running it.

If you can’t even trust your own virus and malware checkers to do their job, that’s not my problem.

The CEMPLLA v1.5 Install program answers all of your questions. It has extensive pop-up documentation, available before you even make the decision to install anything.

So what’s a “blind” .ZIP file? Oh yeah, it’s just a .ZIP file.
And what’s a “blind” .EXE file? Oh yeah, it’s just an .EXE file.

So what is “blind” rumor-mongering? Oh yeah, it’s just B.S.

So, yes, the CEMPLLA v1.5 Install program is a .zipped up Windows 64-bit .exe file. As is 95% of all the Windows software out there. And the rest are .msi files.

Oh wait, I guess I should have called those “blind” .msi files.

So here’s an idea. If you’re uncomfortable about giving CEMPLLA a try, then don’t. That way, you’ll be safe from any imaginary boogey men, and I won’t have to suffer through your baseless, pointless blather about what the CEMPLLA Install program might be - but isn’t.

And yes, CEMPLLA v1.5 displays the 64-bit residue for every iteration it completes.

So why the flame-fest? I guess Mersenne Research, Inc. must really be worried that CEMPLLA really is a threat to what it has always imagined to be it’s monopoly on the EFF awards.

Well gee, sorry, not a big fan of monopolistic corporations. I guess they’ll just have to make do with their “Mlucas” or whatever, for the next, what is it? Oh yeah. “850 years”. Yeah. That’s the consensus right? “850 years” to eliminate a single billion decimal digit Mersenne Prime candidate? Yeah, I can read…

I didn’t run it because my computer runs Linux, which your program doesn’t support. And since you put the documentation inside the installer, I can’t even read it. But I think people are right to be suspicious of an executable file from an unknown source (which you are to everyone in the world outside of your friends and family), especially when they can’t see the source. So even 64-bit Windows users get a pass from me.

I’m surprised you would suggest that running an antivirus scan would be sufficient protection. For a new unknown .exe, all they can do is some fairly weak heuristics, and as you may know Rice’s theorem puts strong limits on what can be proven about program behavior (including whether a program is malware or not).

I don’t know what you have against GIMPS, I guess this is your own personal windmill against which you’ve chosen to tilt. Personally I’d love it if you had actually found a way to discover large primes faster than them, but it seems unlikely, and the paucity of information pushes my thoughts further in that direction.

For what it’s worth I’m not a part of GIMPS or their nonprofit Mersenne Research; I don’t even run their software.

I have, and in time, you’ll know that.

As for your interpretation of the “paucity of information” (great turn of phrase) I don’t see any actual “information” being presented - just a whole lot of scare-mongering what ifs. That’s not what I call “information”.

Be that as it may however, you’re running Linux, so for you, the point is fairly moot. Pity.

As for Mersenne Research, Inc., if you had to suffer through as many of their Internet “hit men” as I’ve had to, you’d probably feel the same way. But you haven’t, so you don’t. That’s understandable. But I didn’t “choose” what you call this “personal windmill” (I’m actually unfamiliar with that term), any more than a victim “chooses” to be bullied.

CEMPLLA works, and time itself will bear me out.

When I referred to information, I was talking about the speed of your program. Do you have timing information on some exponents? Something like exponent – number and types of GPUs – time – residue would really help everyone understand how fast your program is. Without that it’s like claiming to have a record-breaking race at without telling us how fast it goes… kind of disappointing.

Frankly, if you coded something all on your own that was 10% slower than Prime95 that would be a great success, so if you’re faster that’s even more impressive. Of course there are issues in determining how to compare CPU- to GPU-based programs; probably best would be to scale by total system wattage. But that detail can be left for later. For now, any numbers would be an improvement.

Well, there’s an understatement. I think it’s much more than a question of “issues” (no offense). To me, there’s no comparison between a GPGPU application and a CPU-based program, simply because a CPU-based program is not hardware extensible, whereas a (properly programmed) GPGPU application is. Sure, you can have CPU-based “cluster” networks, but then the bandwidth becomes an issue - and not a trivial one. In fact, in my early research, I considered that approach, but the bandwidth between the machines killed the whole idea before the get go.

With a properly programmed GPGPU application, the more GPUs you add, the faster it will run. That’s how CEMPLLA works. In fact, it doesn’t even rely on the CPU for any of the critical number-crunching, and that’s by design. If it runs too slow, it means “add another GPU card”, not “this won’t work”.

I’ve never run that program, but obviously, given enough NVidia brand GPU cards, of course CEMPLLA will be faster - by orders of magnitude, depending on hardware. Assuming that what I keep repeating is true - that the more NVidia brand GPUs you add, the faster CEMPLLA will run - than how could it not be faster than any CPU-based program that is trying to do the same thing?

It’s simply the difference between a hardware-extensible program, and one that isn’t.

But to answer your question directly, once CEMPLLA is installed, timing it is a breeze. I’ve done it countless times on my machine. You just need a modern cell phone with a “stopwatch” capability. When the current iteration count (which is displayed by CEMPLLA at all times, unless you turn it off) hits whatever you want it to hit (25 or higher is recommended), start the stopwatch. Then wait until it has completed whatever number of iterations you think will produce a good sampling, then stop the stopwatch. Divide the number of seconds on your stopwatch by the number of completed iterations (ending iteration minus starting iteration), giving you ‘iterations per second’, then multiply that by two less than the binary exponent of the Mersenne Prime Candidate that you’re testing. That will give you the total number of seconds that it will take to test that Mersenne Prime Candidate.

What I found when testing same on my own limited hardware was that the amount of time it takes to complete an LLT for a particular Mersenne Prime Candidate may sometimes be less than the time it takes to do the same for a Mersenne Prime Candidate of lesser value. It’s not a linear correspondence, as one would expect. In fact, at certain intervals, as one scaled up the binary exponent, and almost completely dependent on the GPU hardware configuration, the total testing time for each candidate would exhibit a “quantum drop” in value. Which, unfortunately for me, ultimately trashed my idea of adding a “bench-marking” option to CEMPLLA, which I had wanted to do.

But any timings that I’ve performed would be meaningless to publish, because my GPU hardware is not what CEMPLLA requires. In fact, the very last time I ran CEMPLLA on my machine, it very correctly erred out after ten minutes with the message “At this rate, you’ll never get a result, so proceeding is pointless.” (which is by design)…

Lastly, should anyone wish to continue this thread, please continue it in a location that isn’t the “Announcements” section. It really no longer belongs here. Speaking of which, I’d be happy to host a “CEMPLLA Participants” section, if the webmaster(s)/moderator(s) of this site are agreeable to that. Contingent, of course, on whether or not anyone actually installs it…

Sorry for the duplication. The “edit comment” didn’t work as I expected. The second one is the updated version.
I changed “iterations per second” to “seconds per iteration”…

You have read EFF Cooperative Computing Awards Rules | Electronic Frontier Foundation since the original posting on mersenne forum right ? If so, you clearly didn’t understand section 3, where you have to give the source code, for EFF to freely publish, before things are awarded. So, unless you find both, then make your claims, you can’t follow through with what was originally said about “The source code is not included in the distribution, but will be released to the general public for full peer review when both of the above prime numbers have been discovered.” ( quoted by chalsall in post 6 of the mersenne forum thread) while getting the prizes.

Well, see, that’s your problem. You’re quoting an idiot.

Garbage in, garbage out…

CEMPLLA documentation has always made it very clear that once either of the award-winning primes are discovered by CEMPLLA, this author will publish the article that, among other things, releases the source code, in order to win the award (duh!).

So why are you still posting? You’re obviously never going to install CEMPLLA, so why are you still here?

Maybe I should sound that out for you - would that make it clearer for you?

There’s a limit to how many GPUs you can put on a motherboard, and there’s a limit to how many cores you can put on a socket and how many sockets you can put on a motherboard. In any of these cases communication isn’t cheap, and it only gets more expensive as you move to connect different systems on the same or adjacent racks and then much more so as you connect to others on the web. But I’m not sure how much this matters since LL, at a glance, seems inherently serial – it’s not clear that you can get a great speedup even with fast interconnects. Certainly scaling is much less than linear.

But there’s a natural way to compare CPUs, GPUs, and more exotic architectures like Knights Landing: look at the number of joules consumed by a system while testing a given collection of exponents. This could be estimated from timing data and the GPUs used in the case of CEMPLLA. Would you give some numbers so we can see how efficient it is? (It would be best to include the residues to check that they’re correct; mask the lowest hex digit or two if you like.)

It’s not very impressive if you can beat a single 21 W CPU core with 2000 W of GPUs, that’s just throwing a lot of power at the problem. It’s very impressive if you can beat it by a factor of 100 (you’re using more power, but speeding it up massively). It would be revolutionary if you could beat it by a factor of 500.

You say “obviously”, but without numbers it is not obvious. P is not known or believed to equal NC.

I’d rather compare with a completed test if possible, rather than extrapolating from a small sample. That would also let me check that the residue is correct. But as my computer runs Linux and you don’t support that, all I can do is ask you to give some of these results. If you’ve done them countless times, surely you can share some so we can have an idea of how fast it is on different exponents?

Do you know of anyone who has hardware that doesn’t cause this error?

I’d still like to know of your results on smaller exponents, if that’s possible. If not, how do you know that it’s working properly? Or more importantly, how would we know that?

Look, it’s really very simple.

CEMPLLA is offered to the public on a “try before you buy” basis - only there’s nothing to “buy”, and CEMPLLA is not “crippled” in any way, shape, or form.

But that doesn’t obviate the requirement to “try” it, which is the operative word in the aforementioned paradigm.

If you’re unwilling or unable to “try” it, then you’re giving it a pass. By definition.

CEMPLLA itself answers all of the questions you’ve posed, and more. As for benchmarks, and in line with industry standards, that’s more of a concern for the active User Base of a software product, if and when they want to get together to discuss such matters amongst themselves. And that is as it should be, because only a User Base has the breadth of hardware diversity required to garner any kind of meaningful results.

What you haven’t stated explicitly in your comments is that you simply don’t believe that I’m on the level; that I could be some kind of software pirate, or worse, and you want proof that I’m not.

So let me be clear. I offer no such proof. To you or anyone else. Because, quite frankly, it’s beneath me.

And you’re free to interpret that any way you’d like.

Let me get this straight. We also don’t know what the program does because you’ve refused to detail the algorithm(s) used. We have no idea how fast it is, nor if it even works. And we can’t verify any of it since you also haven’t released the source. But you expect people to spend their electricity, time, and air conditioning running your mystery program?

That’s a little disturbing, frankly.

I’ve done my best to give you the benefit of the doubt, but I just can’t see a good reason to run this program, even if you release a version that I can run. If you decide to discuss some of the algorithms you use I’d be happy to join in. I might even be able to offer some tips on the numerical analysis. But if you remain in your own walled garden like a King of Pointland, I can’t imagine you’ll have many users take you up on your offer.

CEMPLLA version 1.51 has just been released.

This new version adds a new utility, called “AddCandy”, that enables adding as many Mersenne Prime Candidates as you want to your existing CEMPLLA System Prime Candidate repository. So now you’re no longer limited to only those Prime Candidates that CEMPLLA initially comes installed with.

The new utility, however, is not installed by the CEMPLLA Install program, nor will it be deleted by the CEMPLLA Uninstall process. Instead, it just exists as a standalone executable in the distribution .zip file. So if you want a shortcut to it (once you unzip it), you’ll have to make one for yourself. It doesn’t need to be in any particular folder to run, but it does require CEMPLLA to be installed.

Other than that, there’s no real change from version 1.5, except the correction of some minor typos in the documentation, and a fix for a single, really tiny ‘bug’ in CEMPLLA that caused it to over-allocate memory by about 100K bytes during operation of one of its optional peripheral features (don’t worry - it wasn’t a memory ‘leak’, just an over-allocation).

A brief “Contents.txt” was also added to the distribution .zip file.

To download the new CEMPLLA v1.51 (free of charge or obligation, as always), go to: