So, there are some altcoin mining algorithms now that run cool, such as X11 and groestl. By cool, I mean even when mining at full GPU capacity, the card still remains at 60C or cooler with little to no fans, and drawing little power when compared to scrypt or sha-256 mining.

What mechanism is it that makes these algorithms run cooler than other proof of working algorithms?

  • Some algorithms don't demand as much from the GPU's processors as others. Scrypt-n runs cool and you can even watch a video at top capacity for memory is the main stopper for it, rather than number of processors working together.
    – Joe Pineda
    May 2, 2014 at 11:44
  • @JoePineda in my experience, scrypt-n does not run cool heh
    – Earlz
    May 2, 2014 at 14:49
  • really? Oh, might be a case of "your mileage might vary". I loved watching movies whilst mining Vertcoin :)
    – Joe Pineda
    May 3, 2014 at 19:57

1 Answer 1


With any given algorithm and hardware, there's something that will be the bottleneck: this portion is taxed to its full 100% capacity, while the rest of the hardware is used at <=100% of its capacity. Different portions of the hardware take different amounts of power and heat to run to capacity. Creating an algorithm that taxes the lower-power portions, while leaving the high-power portions largely free, results in a cooler-running algorithm.

For example, let's say you have one algorithm that's heavily processor-bound, and one that's heavily memory-bound. It'd be perfectly reasonable to expect that the processor-bound one runs hotter than the memory-bound one, so if you want your algorithm to run cool, you choose the memory-bound one.

I should also note that some processes are complicated enough that there is no one bottleneck, but it shifts from time to time (e.g. if you read data from your hard drive, compress it, and transfer it over the network, you might have three completely separate bottlenecks at the different times: disk IO, CPU power, and then network IO). You can view this as a composite of algorithms that individually (should) follow the general rule I outlined above.

  • My Cuckoo Cycle proof-of-work (github.com/tromp/cuckoo) minimizes the amount of computation and maximizes random access to global memory, resulting in about 2/3 of running time spent waiting for memory latency and running cool.
    – John Tromp
    Jul 15, 2014 at 19:24

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.