Anyone can shed some light how actually the Miner utilizes GPU as well ?
To my recollection the original nonce pool (the only ever working pool for gapcoin), just utilized the CPU mining function.
See:

https://github.com/noncepool?tab=repositoriesThe GPU miner was a 'work in progress' when the developer sadly passed away (and the pool closed), as was the CRT (CPU) function for RPC mining.
In terms of pooled mining (and continued miner development), the following likely ensues, moving forward ...
1. Pooled CPU mining using GapMiner.
2. Pooled GPU mining using GapMiner (requires development)
3. Pooled CPU / GPU mining using GapMiner CRT function (as above)

https://en.wikipedia.org/wiki/Chinese_remainder_theoremN.B. at this point Quanta Magazine will likely be on the phone or we will have opened a StarGate  lol
...
"1. CPU mining using GapMiner"
 should be incredibly straight forward for yourself to get working 'ocminer', given your fantastic history in the crypto space!
Also, see:

https://github.com/gapcoinproject/GapMiner...
TBH I have not needed to do much myself in this regard due to lack of community involvement in recent years.
EDIT: I've gone back through the thread and here are the relevant posts ...
N.B. The above mining improvment was integrated into j0nn9's last wallet release i.e. the most optimized CPU miner is already in the wallet.
...
...snip...
The algorithm:The average length of a prime gap with the starting prime p, is log(p),
which means that the average prime gap size increases with lager primes.
Instead of the pure length, Gapcoin uses the merit of a prime gap,
which is the ratio of the gap's size to the average gap size.
Let p be the prime starting a prime gap, then m = gapsize/log(p) will be the merit of this prime gap.
Also a pseudo random number is calculated from p to provide finer difficulty adjustment.
Let rand(p) be a pseudo random function with 0 < rand(p) < 1
Then, for a prime gap starting at prime p with size s,
the difficulty will be s/log(p) + 2/log(p) ∗ rand(p),
where 2/log(p) is the average distance between a gap of size s and s + 2 (the next greater gap) in the proximity of p.
When it actually comes to mining, there are two additional fields added to the Blockheader, named “shift” and “adder”.
We will calculate the prime p as sha256(Blockheader) ∗ 2^shift + adder.
As an additional criterion the adder has to be smaller than 2^shift to avoid that the PoW could be reused.
Mining:For mining, PoWCore uses a basic prime sieve with some slightly improvements:
The sieving steps:Calculate the first n primes.
In the actual sieve we skip all even numbers,
because we want to only sieve the odd multiplies of each prime.
So, we create an additional set of primes and multiply each with two.
Make sure the start_index of the sieve is divisible by two.
Now calculate for each prime the first odd number in the sieve,
which is divisible by that prime (called pindex).
For each prime p: mark the pindex as composite,
add 2 ∗ p to pindex and mark it as composite,
redo till we reach the end of the sieve.
For each remaining prime candidate,
check primality with the Fermatpseudoprimetest as it is faster than the MillerRabintest
(Fermat is not as accurate as the MillerRabin and maybe some valid sieve results will not be accepted, but this should be very rare)
Now scan the remaining (pseudo) primes for a big prime gap.
Additional notes:start–index can be hash ∗ 2^shift + [0, 2^shift)
max sieve size depends on start index, and is limited by (hash + 2^shift)  start_index.
shift can theoretically be in range [14, 2^16),
but nodes can choose to only accept shifts till a given amount (e.g. 512 for the main nodes)
dcct's improvementsWe do not check every remaining prime candidate with the fermat test.
Instead we look how large the gap has to be to fit the required difficulty (max_length).
Then we determine the first prime in the sieve (called pstart).
Now we scan the prime candidates in the range (pstart, pstart + max_length).
We start at the position (pstart + max_length) and scan every prime candidate in reverse order till we reach pstart.
If we find a prime within the range (pstart, pstart + max_length)
we can skip all other prime candidates within that range and set pstart to that prime.
We redo the above process till we reach the end of the sieve.
So, to sum it up:Gapcoin is researching into the opposite problem than the one of your video above,
but the max prime gap problem and the twin prime conjecture are closely related,
so, maybe Gapcoin's prime gaps could help somehow proving it.
...
Improved GPUMiner (experimental):Windows:
https://github.com/gapcoin/GapMiner/releases/download/gpuminerrev3/windows.zipmd5: 6e0fa4a4331c3758bec1fc74334aa753
Linux:
https://github.com/gapcoin/GapMiner/releases/download/gpuminerrev3/linux.zipmd5: 85bb6f69b22de5e51388155e7b532195
Source Code:
https://github.com/gapcoin/GapMiner (branch gpuminer)
The Miner is still a bit buggy, but it produced good results for the last few hours,
so I decided to release a test version.
About the speed: I managed to get around
1,200,000 pps with a single AMD R9 280, that's a
6x speed increase to the previous GPUMiner.
I could also reduce the memory load.
Only the Sieve still runs on the CPU.
Also the 10 and 15 gaps per hour are replaced with tests per second,
which are the number of primality tests calculated per second.
The algorithm:The sieve is splitted into parts of the required gap size,
then simultaneously, the prime candidates from each part are tested,
starting from the end of the part and skipping those parts which have a prime in it.
When using the e switch you'll get an info about the current average number of prime candidates of those parts
(candidates which are not tested yet).
Also the minimum number of prime candidates to test are listed.
In one gpu run, several candidates from each part are tested,
you can control these number with n
Debugging:For debugging there are two options added to the Makefile,
one for debugging while mining, these are some tests, which shouldn't have a great impact on the pps
and one for debugging only. Activating the second option will run several time intensive tests while mining,
which has a huge impact on the pps.
...
...
New experimental GapMiner release (CPU only)Revision 5: capable of using the Chinese Remainder Theorem to speed up mining with large shift.
windows:
https://github.com/gapcoin/GapMiner/releases/download/crtrev5/gapminerwindowsrev5.zipmd5: dbae859b1e8825f4f9b3f693004833c4
linux:
https://github.com/gapcoin/GapMiner/releases/download/crtrev5/gapminerlinuxrev5.zipmd5: 909f7fcb141a23d60b04ba8c0df1f391
source code:
https://github.com/gapcoin/GapMiner/archive/crtrev5.zipsource code PoWCore:
https://github.com/gapcoin/GapcoinPoWCore/archive/master.zipThe usage should be pretty self explaining from the startgapminer file.
There are different CRT files containing values optimized for a specific shift.
There are 3 new verbose outputs:
 gaps/s: The amount of gaps scanned per second
 gaplist: The number of sieved gaps ready for scanning
 block: The percent of the calculation amount of an average block
The primes per second and the block percent values are estimated using the theoretical speed improve from the CRT, so they don't have to be correct.
Mining with the CRT is optimized for solo mining.
You can mine at the pool, but you will probably mine less shares, and the pps and block values are probably incorrect, but your chance of finding a block is almost the same as when mining solo.
Mining with the CRT is splitted in sieve and primality testing using separate threads for each:
threads 4 fermatthreads 1
means: 3 sieve and 1 gap scan thread. So you have to use at least 2 threads.
The scan threads always pick the most promising gap from the gaplist, therefore the gaplist value should always be at least over 100, but a too high gaplist value can slow down mining, (for example over 9000). You can alter sieveprimes, threads or fermatthreads to achieve this.
(sievesize is not used for CRT mining)
FYI: The gaplist is implemented as an
heapThe is also an logging version, which produces additional output in a gapminer.log file.
If something goes wrong, you can switch versions, and look whats wrong, or at least give feedback.
...
CTR GapMiner UpdateNew Feature:
Creating custom ctr filesThe ctr algorithm is divided into 2 parts. The first part,
is a simple greedy algorithm which ties to find offsets
for each involved prime, so that the desired number range
has at least prime candidates as possible.
The second part is an evolutionary algorithm, which tries to improve the
results form the greedy algorithm. Therefor the greedy algorithm
will be executed several times with slightly different parameters, to produce
ctrs which differs in quality, which than can be used by the evolutionary algorithm.
The output is a text file which can be used by gapminer as an input for ctr sieving.
Parameter description:
calcctr Indicates that we want to calculate a ctr file.
ctrstrength This is used to variate the computing time spend
within the greedy algorithm. Higher strength
can yield better results.
ctrprimes The number of primes to use in the ctr file. The more
primes the better the ctr result, but the shift
also increases. Minimum shift can be calculated as
the binary logarithm of the product of all primes:
log2(p1 * p2 * ... *pn).
ctrevolution Whether to use the evolutionary algorithm or not.
ctrfixed This number indicates the number of starting primes
which wound get touched by the evolutionary algorithm
the offsets for the primes 2,3,5,7,11... are mostly
perfect computed by the greedy algorithm, and changing
them only declines the result.
ctrivs The number of individuals used in the evolutionary algorithm.
More increases computing time but mostly also the
result quality.
ctrrange Percent deviation from the number of primes.
Useful if you don't want to look for a specific number
of primes.
ctrbits The shift value you later use for sieving has to be greater
than log2(p1*p2*..*pn). With this flag you can fine tune a specific
shift by setting this to shift  log2(p1*p2*..*pn).
ctrmerit The target merit (while testing the ctr it seamed that
sieving for targetmerit  1 yields the best results)
ctrfile The target ctr output file. You can open this with a
text editor. Look for the n_candidates value, the smaller
it is the better the ctr file.
windows:
https://github.com/gapcoin/GapMiner/releases/download/crtrev5.1/windows.zipmd5: 50b506c6fdacbe36dd2d87e6f2c296d9
linux:
https://github.com/gapcoin/GapMiner/releases/download/crtrev5.1/linux.zipmd5: 88f0a3975df728566d3500b69475a78a
source code:
https://github.com/gapcoin/GapMiner/ Again, It's a stark realization that Gapcoin has never been mass GPU mined and/or that the CRT mining could also be implemented into GPU (pooled) mining ...
Gapcoin '
smashed' the world prime gap record MERIT with about 20+ nodes and without a pool!
"Imagine the ASIC's" ...
Additional ...
In terms of developing Gapcoin's ProofofWork function moving forward ...
we can probably count the number of true Prime Gap experts / mathematicians on just over one hand ...
Together and Alone, Closing the Prime Gap
https://www.quantamagazine.org/mathematiciansteamupontwinprimesconjecture20131119After Prime Proof, an Unlikely Star Rises
https://www.quantamagazine.org/yitangzhangandthemysteryofnumbers20150402Prime Gap Grows After DecadesLong Lull
https://www.quantamagazine.org/mathematiciansproveconjectureonbigprimenumbergaps20141210Unheralded Mathematician Bridges the Prime Gap
https://www.quantamagazine.org/yitangzhangproveslandmarktheoremindistributionofprimenumbers20130519/...
Terence Tao

https://en.wikipedia.org/wiki/Terence_TaoJames Maynard (mathematician)

https://en.wikipedia.org/wiki/James_Maynard_(mathematician)Yitang Zhang

https://en.wikipedia.org/wiki/Yitang_ZhangKevin Ford (mathematician)

https://en.wikipedia.org/wiki/Kevin_Ford_(mathematician)Ben Green (mathematician)

https://en.wikipedia.org/wiki/Ben_Green_(mathematician)Sergei Konyagin

https://en.wikipedia.org/wiki/Sergei_Konyagin