BTCO Anomp Pool: https://anomp.cc/?lang=en
stratum+tcp://gpus.anomp.cc:4111      500000 NiceHash Difficulty,
stratum+tcp://gpus.anomp.cc:4112      30000-150000 Difficulty, 
Fee 1%

Introducing Bitcoin Oil: The Next Evolution of Bitcoin – Faster, Smarter, and Built for the Future!

Greetings, crypto enthusiasts!
We are thrilled to present Bitcoin Oil – a groundbreaking alternative to the original Bitcoin, designed to take everything great about Bitcoin and supercharge it! If you’re familiar with Bitcoin Gold and Bitcoin 2, you’ll understand the potential of altcoins – but Bitcoin Oil brings the game to a whole new level.
What Makes Bitcoin Oil Special?

While Bitcoin Oil uses the same trusted SHA-256 algorithm as Bitcoin, it’s better and faster in key areas:

BTC    Faster Transactions: With a block target time of 6 minutes, Bitcoin Oil accelerates the pace. This means faster transactions while maintaining the security and decentralization we all value. No more waiting around for confirmations!

BTC    Coinbase Maturity in Just 10 Hours: Mined coins can be spent after just 100 blocks – that’s only 10 hours before you can put them into use, compared to Bitcoin's much longer waiting period. Speed and liquidity are at the heart of Bitcoin Oil!
BTC    Better Difficulty Readjustment: Every 24 minutes, Bitcoin Oil’s difficulty adjusts, ensuring quick reactions to mining fluctuations, making the network more efficient. Yes, it might lead to a larger blockchain, but storage costs are only going down, especially as cloud storage continues to get cheaper compared to when Bitcoin launched back in 2009.

A Symbol of Wealth and Progress

The name Bitcoin Oil isn’t just a cool moniker. It symbolizes the merging of two iconic wealth instruments from different eras – oil, which fueled the industrial age, and Bitcoin, which is driving the digital age. This fusion represents strength, opportunity, and wealth for those ready to embrace the future!

Important: While it’s called Bitcoin Oil, this coin is not pegged to oil prices – it's an independent asset built to stand on its own in the crypto world.

The Early Bird Advantage

Early miners, pay attention! With an initial block reward of 50 Bitcoin Oil, and difficulty starting low, the early days of mining are ripe for those who act fast. Right now, the network is set to generate 10 blocks an hour, meaning early miners can stack up units before the crowd rushes in.

BTC   Total Supply: Just 18,590,000 Bitcoin Oil will ever be mined. This number pays homage to the first US oil well drilled in 1859. Limited supply, early mining advantages, and fast transactions make Bitcoin Oil the perfect blend of opportunity and innovation.

BTC   Halving Events: Every 185,900 blocks, Bitcoin Oil will go through a halving cycle. This means every two years and 1 month (assuming perfect block time), the block reward will reduce, mimicking Bitcoin's scarcity-driving mechanism – but with faster intervals. Get in early and enjoy higher rewards before the next halving!

Why Bitcoin Oil?

Bitcoin Oil is Bitcoin on steroids – faster, more efficient, and ready for modern-day demands. Imagine all the perks of Bitcoin, but with faster transactions, more predictable mining adjustments, and the chance to be part of something bigger from the very beginning. This is your chance to mine a cryptocurrency built for the future!

Don’t miss out on this opportunity! Be among the first to experience Bitcoin perfected. Get involved today, and ride the wave of innovation with Bitcoin Oil!

Let's fuel the future, together. 💥

Attribute	Bitcoin (BTC)	Bitcoin Oil (BTCO)
Block Time	10 minutes	6 minutes
Coinbase Maturity	16 hours	10 hours
Difficulty Readjustment	2 weeks	24 minutes
Halving Interval	Every 4 years	Every 2 years and 1 month (assumed)
Max Supply	21,000,000 BTC	18,590,000 BTCO

Website: https://bitcoinoil.org
X: https://x.com/Bitcoin_Oil
Source code: https://github.com/escapeneo/bitcoinoil

Try these:
addnode=216.238.81.202:51400
addnode=37.27.46.65:51400
addnode=206.217.131.88:51400
addnode=184.148.33.132:51400
addnode=107.173.11.236:51400
addnode=149.28.34.182:51400
addnode=140.82.6.80:51400
addnode=64.176.193.63:51400
addnode=149.28.233.244:51400

PatriotBit

Github: https://github.com/whatkindamericanareyou/J6Q
Block Explorer: http://bits.silentpatriot.com/
Wallet Download (WIN): https://github.com/whatkindamericanareyou/J6Q/releases/download/v1.06.2021/PatriotBit-SCIF-v1.06.202.zip
Algorithm: C11
 

System Includes:

• FREE OPEN SOURCE SOFTWARE
• Digital tokens to mine, send, share, store, hoard, burn, etc.
• Blockchain based messaging, masternodes, coin-control
• Eagles and Freedom

System DOES NOT Include:

• SUPPORT, ASSISTANCE, WARRANTY OF ANY KIND WHAT-SO-EVER
• Advertising, shills, moon-sayers, or developers
• Promise of ANY future value
• Care about your feelings

PatriotBits are simple, free, worthless digital tokens that enable pseudonymous transfers to anyone, anywhere on network.

PatriotBit uses ancient peer-to-peer technology to operate with no central authority: managing transactions and issuing tokens is carried out collectively by the network.
 
PatriotBit is an open project and there are no "Developers." The SCIF is 10 year old software built on a 20 year old laptop for the sake of having something to do on a Friday night. It is designed to install and run on all NT-level Windows systems or Debian Jessie.
 
License

PatriotBit is released under the terms of the MIT license. See COPYING for more information or see http://opensource.org/licenses/MIT.
 
By using PatriotBit, the PatriotBit P2P Network, or the PatriotBit SCIF you are accepting 100% liability and responsibility for your J6Q and J6Q network connections. The maker of PatriotBit does not market or warranty PatriotBit and makes ABSOLUTELY NO CLAIM or promises for future use or value. By utilizing the J6Q client, you acknowledge that this is experimental, worthless software and that you are realizing the risks and rewards inherent in using crypto-tokens.

void hashx7(void *state, const void *input, uint64_t timestamp)
{
    uint32_t _ALIGN(64) hash[7][16];
    uint32_t *hash0 = hash[0];
    uint32_t *hash1 = hash[1];
    uint32_t *hash2 = hash[2];
    uint32_t *hash3 = hash[3];
    uint32_t *hash4 = hash[4];
    uint32_t *hash5 = hash[5];
    uint32_t *hash6 = hash[6];
   
    x7_context_overlay ctx;

    // Blake512
    sph_blake512_init(&ctx.blake);
    sph_blake512(&ctx.blake, &timestamp, sizeof(timestamp));
    sph_blake512(&ctx.blake, input, 80);
    sph_blake512_close(&ctx.blake, hash0);   

    // BMW512
    sph_bmw512_init(&ctx.bmw);
    sph_bmw512(&ctx.bmw, hash0, 64);
    sph_bmw512_close(&ctx.bmw, hash1);

    // XOR with hash0
    for (int i = 0; i < 64; ++i) {
        hash1 ^= hash0;
    }

    // groestl   
#if defined(__AES__)
    groestl512_full(&ctx.groestl, (char*)hash2, (const char*)hash1, 512);
#else
    sph_groestl512_init(&ctx.groestl);
    sph_groestl512(&ctx.groestl, hash1, 64);
    sph_groestl512_close(&ctx.groestl, hash2);
#endif

    // Skein512
    sph_skein512_init(&ctx.skein);
    sph_skein512(&ctx.skein, hash2, 64);
    sph_skein512_close(&ctx.skein, hash3);

    // XOR with hash2
    for (int i = 0; i < 64; ++i) {
        hash3 ^= hash2;
    }

    // Keccak512
    sph_keccak512_init(&ctx.keccak);
    sph_keccak512(&ctx.keccak, hash3, 64);
    sph_keccak512_close(&ctx.keccak, hash4);

#if defined(__aarch64__)
    sph_luffa512_init(&ctx.luffa);
    sph_luffa512(&ctx.luffa, hash4, 64);
    sph_luffa512_close(&ctx.luffa, hash5);
#else
    luffa_full(&ctx.luffa, hash5, 512, hash4, 64);
#endif

#if defined(__AES__)
    echo_full(&ctx.echo, (BitSequence *)hash6, 512, (const BitSequence *)hash5, 64);
#else
    sph_echo512_init(&ctx.echo);
    sph_echo512(&ctx.echo, hash5, 64);
    sph_echo512_close(&ctx.echo, hash6);
#endif

    // XOR with hash5
    for (int i = 0; i < 64; ++i) {
        hash6 ^= hash5;
    }

    memcpy(state, hash6, 32);   
}

Hello! How does ccminer handle the algorithm with timestamp in sph_blake512(&ctx.blake, &timestamp, sizeof(timestamp)); algorithm?

All other algorithm problems have been solved, but I don't know how to deal with the timestamp.

http://ccminer.org/img/ccminer-banner.png

Welcome to the discussion thread for my ccminer fork.

It contains most algorithms, and was adapted to be usable on both linux and windows.
My releases are generally tuned with the Geforce GTX 750Ti, which was, and still is a good reference for tests (Linux + Windows) and has less hashrate drop in activity (unlike the 9xx and pascal series).

For a comprehensive list of the algorithms supported as well as details about the various configuration parameters, please check the ReadMe file.

Direct links

---

Windows Binaries : https://github.com/tpruvot/ccminer/releases
Source Code : https://github.com/tpruvot/ccminer
Linux, read first : https://github.com/tpruvot/ccminer/wiki/Compatibility
Sample Command Line : ccminer -a bitcore -o stratum+tcp://yiimp.eu:3556 -u 1Hpjgz8i4aRdnmLXm9Eri8fFgje2dA9BaQ -p c=BTX


http://cryptomining-blog.com/wp-content/uploads/2017/03/ccminer-20-tpruvot-580x293.jpg

This is the home of cpuminer-opt, the optimized x86_64 CPU miner.

Supporting over 90 agorithms with many optimized for x86_64 CPUs with the latest technologies:

Intel Haswell: AVX2
AMD Zen1: AVX2 and SHA
AMD Zen3, Intel Alderlake*: AVX2, SHA and VAES
Intel Skylake X: AVX512
AMD Zen4, Intel Rocketlake: AVX512, SHA, and VAES

Older 64 bit CPUs with SSE2 are also supported, see below for requirements.
*Alderlake and subsequent Intel desktop architectures are hybrid architecture with AVX512 disabled.
Intel has no current consumer desktop CPUs supporting AVX512.

Downloads

Source code and Windows binaries are avaiable for download. Windows binaries support CPUs up to 64 threads,
higher requires compiling from source with CPU group support, see Wiki for details.
Download only from the official JayDDee git repository.
There may be malware masquerading as cpuminer-opt, stay alert.
I no longer post links in new mesages and I don't post direct links to files. Any such links should be treated
with suspicion. The only valid download link is below and directs to a landing page that can be examined
for legitimacy before any files are downloaded.

Latest release including Windows binaries
https://github.com/JayDDee/cpuminer-opt/releases

Documentation
https://github.com/JayDDee/cpuminer-opt/wiki

List of supported algoritms
https://github.com/JayDDee/cpuminer-opt/wiki/Supported--Algorithms

Source code
https://github.com/JayDDee/cpuminer-opt

New in v3.22.3
Data interleaving and byte swap optimizations with AVX2, AVX512 & AVX512VBMI.
Faster Luffa with AVX2 & AVX512.
Other small optimizations.
Some code cleanup.

New in v3.22.2

Added sha512256d & sha256dt algos.
Fixed intermittant invalid shares lyra2v2 AVX512.
Removed application limits on the number of CPUs and threads, HW and OS limits still apply.
Added a log warning if more threads are defined than active CPUs in affinity mask.
Improved merkle tree memory management for stratum.
Added transaction count to New Work log.
Other small improvements.

New in v3.22.1

#393 fixed segfault in GBT, regression from v3.22.0.
More efficient 32 bit data interleaving.

New in v3.22.0

Stratum: faster netdiff calculation.
Merged a few updates from Pooler/cpuminer:
   Use CURLOPT_POSTFIELDS in json_rpc_call,
   Use CURLINFO_ACTIVESOCKET when supported,
   JSONRPC speedup,
   Speed up hex2bin function.
Small log improvements, notably more frequent hash rate reports.
Removed decred algo.

Full change log: https://github.com/JayDDee/cpuminer-opt/blob/master/RELEASE_NOTES

Requirements:

1. A x86_64 architecture CPU with a minimum of SSE2 support. This includes Intel Core2 and newer and AMD equivalents.
AES optimizations require a CPU with AES_NI including Intel Westmere and newer and AMD equivalents.
Further optimizations are available on some algorithms for CPUs with AVX (Sandybridge), AVX2 (Haswell, Zen1),
AVX512 (Rocketlake, Skylake-X, Zen4), SHA (Zen1, Rocketlake), and VAES (Zen3, Rocketlake).

32 bit Intel and AMD CPUs are not supported. Other architectures such as ARM, Raspberry Pi, RISC-V, etc, are not supported.
Mobile devices like lapotop computers are not recommended because they aren't designed for continuous full load.

2. 64 bit Linux OS. Debian and Fedora based distributions including Ubuntu, Mint, RHEL and clones are known to work and have all dependencies in their
repositories. Others may work but may require more effort.

Windows 7 or newer 64 bits is supported using the pre-compiled binaries package or may be compiled from source using MinGW.

FreeBSD is not actively tested but should work, YMMV.
Apple and Android operating systems are not supported.

Older CPUs, other architectures and operating systems may be supported by TPruvot's cpuminer-multi.

Security warning

Cryptocurrency miners often flagged as malware by antivirus programs. This is usually a false positive, they are flagged simply
because of what they are. However, some malware has been spread using the cover that miners are known to be subject to
false positives. Always be on alert. The source code of cpuminer-opt is open for anyone to inspect. If you don't trust the software
don't download it.

Some cryptographic code has been taken from trusted sources but has been modified for speed at the expense of accepted
security practices. This code should not be imported into applications where secure cryptography is required.

Errata:

Old algorithms that are rarely used or are too difficult to mine with a CPU will not get the latest optimizations.
Cryptonight and variants are no longer supported, use other miners.
Hodl requires a CPU with AES.

Donations

cpuminer-opt has no fees of any kind but donations are accepted.

BTC: 12tdvfF7KmAsihBXQXynT6E6th2c2pByTT