Sable 1.6 - from-scratch C++ engine with a self-trained NNUE (~3200 CCRL, AI-assisted build)

[Dylan]

Hi all,

I'd like to share Sable 1.6, a UCI engine I built over about a week.

Full disclosure up front, because it's part of why I'm posting it: the code was written by an AI (Anthropic's Claude) working under my direction. I designed the approach, ran all data generation, training and testing on my own hardware, debugged the pipeline, and verified strength at every step. The NNUE was trained from zero on self-play data generated on my own PC (i7-11700K + RTX 3070) — no external data, no pretrained weights, and no code derived from another engine. I'm releasing it partly to show what one person and a current AI model can build together in a few days.

Repo (MIT — source + net + training scripts):
https://github.com/dylan2554/sable

Technical summary

• Bitboards + magic move generation (perft-verified, incl. Kiwipete)
• PVS / alpha-beta, transposition table, null-move, LMR, singular + double extensions
• Reverse-futility / futility / razoring, late-move + history pruning, SEE pruning
• Killers, counter-moves, butterfly + continuation history (with maluses)
• Quiescence with SEE filtering, delta pruning, and quiet checks
• Lazy SMP (1–16 threads)
• NNUE 768->512x2->1, clipped-ReLU, int16 quantized, AVX2 incremental inference
• Net trained across 4 self-play generations (each generation regenerates data using the previous, stronger net to label positions, then retrains)

Strength — single-threaded, the way CCRL tests. Triangulated against engines with published CCRL Blitz ratings, under fair conditions (single thread both sides, equal 128 MB hash, 2'+1"):

Code: Select all

  Opponent (CCRL Blitz)    Sable score   Games   Implied
  Inanis 1.6.0  (~3000)       70%         100     ~3150
  Stash v27     (~3057)      ~76%         180     ~3260
  Stash v30     (~3166)      ~54%         180     ~3195
  Stash v32     (~3252)      ~43%         180     ~3200

The anchors agree on roughly ~3200 CCRL single-threaded. This is my own estimate, not an official listing — I'd be very grateful if anyone is willing to test it for a list.

Notes

• Binaries are unsigned, so Windows SmartScreen will warn; or build from source: [c]g++ -O3 -mavx2 -pthread sable.cpp[/c]. A non-AVX2 fallback build is also included.
• Keep [c]sable.nnue[/c] next to the executable — it loads automatically.

Feedback very welcome — this is my first released engine and I'd love to hear how it does on other hardware and time controls.

Thanks!

I wonder if the technical details that you mentioned like Bitboards + magic move generation are things that the AI suggested or things that you suggested to the AI to do when the AI wrote the things based on your suggestions(or maybe part based on your ideas and part based on the AI suggestions how to build a chess engine.

Good question. Honestly, most of the specific technical choices - bitboards, magic move generation, the NNUE evaluation, the search techniques like null-move and LMR, the SIMD inference - were suggested by the AI. My input was mostly at the level of goals and direction: "make it stronger," "add a neural network trained on self-play," "make it faster," "let's try to reach 3000," and so on. I made the judgment calls - which ideas to pursue, whether a result was a real gain or just noise, when to stop chasing something - and crucially I ran all the actual training and testing on my own hardware and fed the results back, which is where a lot of the real decisions happened (a couple of "improvements" turned out to be no better and got dropped after testing).
So it's fair to say the chess-engine know-how came largely from the model, and my role was more director, operator and tester than architect. That division is honestly part of what I found interesting about the whole thing.

[Ciekce]

Full disclosure up front, because it's part of why I'm posting it: the code was written by an AI (Anthropic's Claude) working under my direction.

what is even the point

computer chess is doomed

[j.t.]

While this is an interesting experiment, my suggestion is that chess engine testers and ranking list maintainers prefer to list

https://github.com/Silverrzz/sable

which has been written by a real human for quite a few weeks, in favor of the purely vibe coded engine, despite the fact that the vibe coded engine "by" Dylan was technically released earlier. Maybe Dylan can rename his engine to something else like Cable (a nod to Claude being used and presumably cables were used too).

[op12no2]

somewhat related, I have a model eval using a chess engine here: https://github.com/op12no2/patchwork. this is the prompt edited as needed:-

Code: Select all

using the currenty leading chess engine

./engines/0010_fable_5.js

as your starting point, create a new engine

./engines/0011_grok_4_3.js 

with improved playing strength.

your goal is to become the new leader. 

you may find the content of ./tools/ useful.

Nothing remarkable yet... The prompt is deliberately vague so one could cheat, but so far they have been well-behaved.

"may" is deliberate too. Grok 4.3 for example did not bother (to use any of the tools), whereas Claude Opus 4.8 ran a SPRT and the gauntlet and updated the readme, as did Claude Fable, which also told me it had "plenty more in the tank" - looking forward to running it again when it makes a reappearance.

The idea is to keep running current models until they asymptote (not there yet), then see if new models can make an improvement as they appear.