Source Authorship Forensics

Crustik — human-written, or AI-generated?

A source-level read of Dejon51/Crustik, contrasted with Stockfish — the third in a series alongside the AI-generated Luna and the human-written rudim.

Author Dejon Eltahan (Dejon51 / DeeZ) Language C Scope ~5,500 LoC hand-written (+100k generated tables) · 155 commits Eval Classical HCE (PeSTO), NNUE planned Analyzed 2026-07-10 Method source read + git history + build/test signals Stockfish similarity Independent →
Verdict · Human-Written

A hand-rolled hobbyist C engine — human through and through.

Crustik is genuine, hand-authored engine code with none of the residue of AI generation. The git history shows sustained personal development with OpenBench-style testing discipline; the source carries jokes, abandoned experiments, messy includes, and personal working notes — the texture of a person building something they enjoy. It currently runs a classical hand-crafted evaluation and is on the well-trodden path toward NNUE (self-play data generation is already in place).

No AI assistance is evident in the code at all — no generated-text markers, no incoherent structure. This is a from-scratch project by one developer.

Confidence: High — process history and code texture agree.

Third in a series applying the same forensic lens: the AI-generated Luna, the human-written rudim, and — here — Crustik. Together they map the spectrum from AI-dumped to authentically hand-built.

·Evidence at a glance

Signals of authentic human authorship, strongest first.

#SignalWhat it showsWeight
1155 local commits; bench: NNNNN messages (the OpenBench convention)A real, competitively-tested engine in the community testing loopDecisive
2Commented-out jokes & abandoned experiments left in the sourceThe texture of human iteration; AI first-drafts don't leave gagsDecisive
3Casual, typo-laden README & commits ("Runs on a potato", "Tree fold boken", "Banger")An individual's voice, not generated proseStrong
4Personal DEVBLOG.md of terse future ideas (Nnue, qfsp, faster movegen)Ongoing personal roadmapStrong
5A committer email on nocturn9x.space (a known engine dev's OpenBench server)Plugged into the real computer-chess communityStrong
6Messy human details: duplicate includes, one dev under several aliasesOrganic, hand-maintained codeSupport
7Zero [cite:] markers or other AI residueNo un-scrubbed generated textSupport

1The code has a sense of humour

The single clearest tell is texture no language model produces: jokes and dead experiments left lying around.

// eval.c
// #define ILLEGALMOVE 42 // Answer to the universe

// static uint8_t penaltymap[64] = { 1, 2, 3, 4, ... };   // abandoned experiment, left in

#include "stdio.h"
#include <stdio.h>                                        // included twice — nobody cleaned it up
Why this matters: AI-generated code is uniformly tidy and over-commented; it doesn't leave a Hitchhiker's-Guide gag in a #define, an abandoned lookup table commented out "just in case", or a duplicated header. These are the fingerprints of a person building and revising in place.

2The engineering is real, and classical

Underneath the jokes is competent, hand-written engine code — currently a classical evaluation, not NNUE.

The search (search.c, ~1,100 lines) carries the modern move-ordering toolkit: killers, counter-moves, a main history table, capture history, and a pawn-history heuristic bucketed by pawn structure, plus a transposition table, three-fold detection, and a splitmix64 hash mixer. The evaluation (eval.c) is a tapered mid/endgame scheme built on the community-standard PeSTO values and piece-square tables:

int mg_value[6] = { 82, 337, 365, 477, 1025, 0 };   // PeSTO middlegame values
int eg_value[6] = { 94, 281, 297, 512,  936, 0 };   // PeSTO endgame values

NNUE is a stated future goal in the DEVBLOG, and datagen.c already exists to generate self-play training data — the classic classical → NNUE journey that most hobby engines walk. Move generation uses magic bitboards (the 100k-line rook_table.h is generated attack data, not authored code, which is why the raw line count looks enormous).

3Compare & contrast with Stockfish

Crustik shares Stockfish's classical lineage and testing culture, at an early solo-hobby stage.

Where it resembles Stockfish
Magic bitboards, Zobrist hashing, perft-verified movegen
Tapered mid/endgame eval with piece-square tables (PeSTO derives from this HCE lineage)
Move ordering: killers, counter-moves, history, capture history, pawn history
Transposition table, quiescence, repetition handling
Bench-in-commit / OpenBench testing discipline (the Fishtest ethos)
Where it differs
C, ~5.5k LoC, one hobbyist vs C++, hundreds of contributors over decades
Classical hand-crafted eval today vs Stockfish's NNUE (Crustik has NNUE as a roadmap item, with datagen groundwork)
Early-stage strength vs the strongest engine in the world
Deliberately dependency-light ("runs on a potato") vs a large tuned build system

Bottom line

Crustik is a hand-written, human-authored C chess engine — earlier in its journey than rudim (classical evaluation, NNUE still ahead of it) but no less genuinely a person's own work. It is built the way real hobby engines are built: iterated in place, tested through OpenBench, documented in a personal devlog, and sprinkled with the jokes and loose ends that only a human leaves behind. On the spectrum from the AI-dumped Luna to the polished human rudim, Crustik sits firmly on the human side — just younger.