Igel is a free UCI chess engine forked from GreKo 2018.01. It is not a complete chess program and requires some UCI compatible GUI software in order to be used.

In June 2020 Igel was invited by Andrew Grant to participate in OpenBench testing framework and this has further accelerated the strength improvement of the engine. In August 2020 Igel switched to NNUE as a main evaluation function using Dietrich Kappe's NiNu network file and is currently approaching the top ten strongest chess engines on CCRL list.

In October 2020 first Igel Generation Networks were introduced seeing participation of Igel in TCEC Cup7 and TCEC Season 20 and released later with Igel 2.9.0.

In January 2023 last bits of HCE code were removed from Igel and the evaluation is fully based on NNUE as of Igel 3.4.0.

In late 2020 there have been a lot of discussions in the chess community about NNUE techology in general and NNUE networks in particular raising important questions about authenticity of networks.

I have decided to dedicate time and resources to create my own class of networks that will be used for future Igel releases: Igel Generation Network (IGN).

The IGN networks comply with the following mandatory requirements:

1. Source of network data: evaluation, search, pv line is generated solely using Igel chess engine. As a starting point Igel 2.6.0 is choosen as this was the last version of Igel featuring HCE (Hand Crafted Evaluation)

2. Both data and validation data generation must be following the rule #1

3. Two versions of Igel: 2.7.0 and 2.8.0 are excluded from network training/data generation process (both for data and for validation data) because they use Dietrich Kappe's Night Nurse network as thus violate the rule #1

4. Data generation and network training must be done by myself on my own (or rented by me) hardware in order to make sure the rule #1 is not violated

5. Each generation of network must contain information (on github page) on training parameters for clarity of the source of data

**Technical details**

| Generation | Architecture | Source of data | Quantity | Data Type | Best network |

| ------------- | ------------------------| ---------------------------------- | ----------------- | -------------- | -------------- |

| ign-0 | halfkp_256x2-32-32 | Igel 2.6.0 | 2.3b d8, 500m d12 | HCE | ign-0-9b1937cc |

| ign-1 | halfkp_256x2-32-32 | Igel 2.6.0, Igel 2.9.0, Igel 3.0.0 | 12b d8, 1b d12 | HCE, NNUE | ign-1-9a48854b |

| ign-2 | halfkav2_512x2-16-32 | Igels as of 2.9.0 | d5+d8+d16 >30b | Mostly NNUE | ign-2-51ba2968 |

| ign-3 | halfkav2_hm_1024x2-8-32 | Igels as of 2.9.0 | d5+d8+d16 >30b | Fully NNUE | ign-3-debc71a4 |

Generator::Generator(int depth, int threads, int fFash):

m_maxThreads(threads),

m_maxfHash(fFash)

std::cout << "Training fens hash:" << m_maxfHash << std::endl;

std::cout << "Allocating fen hash table (" << fFash << "GB) ..";

FenHashTT::instance(fFash);

std::cout << ". Done" << std::endl;

uint64_t before_skipped = 0;

for (auto i = 0; i < m_maxThreads; ++i) {

before_skipped += m_workers[i].m_skipped;

}

uint64_t after_skipped = 0;

for (auto i = 0; i < m_maxThreads; ++i) {

after_skipped += m_workers[i].m_skipped;

}

std::cout << "[Processed " << after_processed << " FENs, " << ((after_processed - before_processed) / 15) << " per sec] [" ;

std::cout << "Skipped " << after_skipped << " FENs, " << ((after_skipped - before_skipped) / 15) << " per sec]" << std::endl;

class FenHashTableEntry

{

typedef union {

struct {

U32 move : 24, age : 8, type : 2;

I32 score : 22, depth : 8;

};

U64 raw;

}FenHashEntry;

static_assert(sizeof(FenHashEntry) == 8, "FenHashEntry must be 8 bytes");

FenHashTableEntry()

{

m_data.raw = 0;

m_key = 0;

}

void store(Move mv, EVAL score, I8 depth, U8 type, U64 hash0, U8 age)

{

assert(type >= 0 && type <= 2);

assert(age >= 0 && age <= 255);

assert(depth >= -128 && depth <= 127);

assert(score >= -50000 && score <= 50000);

assert(mv >= 0 && mv <= 16777216);

m_data.age = age;

m_data.type = type;

m_data.move = mv;

m_data.depth = depth;

m_data.score = score;

m_key = hash0 ^ m_data.raw;

// when debugging a multi cpu configuration these may give you a trouble:

assert(age == m_data.age);

assert(type == m_data.type);

assert(mv == m_data.move);

assert(depth == m_data.depth);

assert(score == m_data.score);

}

FenHashEntry m_data;

U64 m_key;

};

static_assert(sizeof(FenHashTableEntry) == 16, "TEntry must be 16 bytes");

class FenHashTT

{

FenHashTT(int hSize) {

size_t fenHash = static_cast<size_t>(hSize) * 1024;

m_hashSize = static_cast<size_t>(static_cast<size_t>((1024 * 1024) * fenHash) / sizeof(FenHashTableEntry));

#if defined(__linux__) && !defined(__ANDROID__)

// on linux systems we align on 2MB boundaries and request Huge Pages

// idea comes from Sami Kiminki as used in Ethereal

m_hash = reinterpret_cast<FenHashTableEntry*>(aligned_alloc(2 * MB, sizeof(FenHashTableEntry) * m_hashSize));

madvise(m_hash, sizeof(FenHashTableEntry) * m_hashSize, MADV_HUGEPAGE);

#else

// otherwise, we simply allocate as usual and make no requests

m_hash = reinterpret_cast<FenHashTableEntry*>(malloc(sizeof(FenHashTableEntry) * m_hashSize));

#endif

assert(m_hash);

memset(reinterpret_cast<void*>(m_hash), 0, sizeof(FenHashTableEntry) * m_hashSize);

}

static FenHashTT & instance(int hSize) {

static FenHashTT instance(hSize);

return instance;

}

void record(Move mv, EVAL score, I8 depth, int ply, U8 type, U64 hash0) {

assert(m_hash);

assert(m_hashSize);

size_t index = hash0 % m_hashSize;

FenHashTableEntry & cluster = m_hash[index];

cluster.store(mv, score, depth, type, hash0, 0);

}

bool retrieve(U64 hash) {

assert(m_hash);

assert(m_hashSize);

size_t index = hash % m_hashSize;

auto pCluster = m_hash + index;

if ((pCluster->m_key ^ pCluster->m_data.raw) == hash)

return true;

return false;

}

mutable FenHashTableEntry* m_hash;

mutable size_t m_hashSize;

static constexpr uint64_t MB = 1ull << 20;

};

GenWorker() : m_exit(false), m_pFile(nullptr), m_pMutex(nullptr), m_counter(0), m_skipped(0), m_search(new Search), m_finished(true), m_maxDepth(1) {}

bool quiet;

if (i.ply > 6 && i.quiet && std::abs(i.score) <= (CHECKMATE_SCORE + MAX_PLY)) {

if (result == "1-0")

res = 1;

else if (result == "0-1")

res = -1;

else

res = 0; // result is a draw

auto check = m_search->m_position.InCheck();

auto hash = m_search->m_position.Hash();

// avoid duplicated fen entries

if (FenHashTT::instance(0).retrieve(hash) == false) {

//

// store the position

//

auto & entry = entries.emplace_back();

entry.fen = fen;

entry.move = move;

entry.score = m_search->m_score;

entry.ply = ply;

entry.quiet = !check && !m_search->m_position.InCheck() && !MoveEval::isTacticalMove(m_search->m_best);

FenHashTT::instance(0).record(m_search->m_best, m_search->m_score, m_search->m_depth, ply, 0, hash);

}

else

m_skipped++;

uint64_t m_skipped;

Generator(int depth, int threads, int fFash);

EVALFILE = weights/ign-3-debc71a4

ifneq ($(findstring __AVX512VNNI__, $(GCCDEFINES)),)

LIBS += -mavx512vnni

DEFS += -DUSE_AVX512=1 -DUSE_VNNI=1