#chess #no-std

no-std cozy-chess

Rust Chess and Chess960 move generation library

10 releases

0.3.1 Sep 27, 2022
0.3.0 Sep 2, 2022
0.2.2 Mar 13, 2022
0.2.1 Jan 8, 2022
0.1.1 Sep 13, 2021

#3 in Games

Download history 5/week @ 2022-11-24 5/week @ 2022-12-01 21/week @ 2022-12-08 8/week @ 2022-12-15 20/week @ 2022-12-22 96/week @ 2022-12-29 72/week @ 2023-01-05 55/week @ 2023-01-12 64/week @ 2023-01-19 49/week @ 2023-01-26 27/week @ 2023-02-02 59/week @ 2023-02-09 39/week @ 2023-02-16 16/week @ 2023-02-23 8/week @ 2023-03-02 29/week @ 2023-03-09

101 downloads per month

MIT license



Rust Chess and Chess960 move generation library


cozy-chess is a Chess and Chess960 (Fischer Random Chess) move generation library written in Rust that aims to provide competitive move generation performance. It is largely inspired by Jordan Bray's neat chess library. cozy-chess aims to be a safer alternative to chess that maintains correctness while providing similar performance.

Cozy Glow


  • no_std compatible
  • Supports Chess, Chess960/FRC, and Double Chess960/DFRC
  • Strongly-typed API that makes heavy use of newtypes to avoid errors
  • Performant legal move generation suitable for use in a chess engine
    • Implements fixed shift fancy black magic bitboards
    • Optionally implements PEXT bitboards based on the BMI2 intrinsic
    • Flexible API produces moves in bulk for optional bulk filtering
  • Efficient bitboard-based board representation
  • Incrementally updated zobrist hash for quickly obtaining a hash of a board

Crate features

  • std: Enable features that require std. Currently only used for the Error trait.
  • pext: Enable PEXT bitboards.

A note on CPU features and performance

By default, Rust binaries target a baseline CPU to ensure maximum compatibility at the cost of performance. cozy-chess benefits significantly from features present in modern CPUs. For maximum performance, the target CPU can instead be set to native to use features supported by the machine running the build. Alternatively, the target CPU can be set to x86-64-v3, which will produce binaries that run on most modern CPUs. The target CPU may be changed by adding -C target-cpu=<CPU> to RUSTFLAGS.

PEXT bitboards are a faster variant of the magic bitboard algorithm used by cozy-chess. PEXT bitboards rely on an intrinsic introduced in the BMI2 CPU extension. However, it is not enabled by default, as PEXT bitboards are slower on AMD CPUs prior to Zen 3, which implement PEXT with microcode. PEXT bitboards can be enabled through the pext feature.


Basic example

# use cozy_chess::*;
// Start position
let board = Board::default();
let mut move_list = Vec::new();
board.generate_moves(|moves| {
    // Unpack dense move set into move list
assert_eq!(move_list.len(), 20);

Get capture moves in bulk

# use cozy_chess::*;
// Parse position from FEN
let board = "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1"

let mut total_moves = 0;
let mut total_captures = 0;

let enemy_pieces = board.colors(!board.side_to_move());
board.generate_moves(|moves| {
    let mut captures = moves.clone();
    // Bitmask to efficiently get all captures set-wise.
    // Excluding en passant square for convenience.
    captures.to &= enemy_pieces;

    total_moves += moves.len();
    total_captures += captures.len();

assert_eq!(total_moves, 48);
assert_eq!(total_captures, 8);

Perft example

A perft implementation exists in examples/perft.rs:

$ cargo run --release --example perft -- 7
   Compiling cozy-chess v0.3.0
    Finished release [optimized] target(s) in 6.37s
     Running `target\release\examples\perft.exe 7`
3195901860 nodes in 10.05s (318045465 nps)




  • Fixed bug where Board::is_legal said castles while in check were legal.



  • Added methods for obtaining Chess960 start positions from their Scharnagl number.
  • Added PEXT bitboards using the BMI2 PEXT intrinsic. Potentially faster than the default algorithm. Enable using the pext feature.
  • Added hash_without_ep method for fast equivalence checks excluding the en passant square.
  • Added Board::same_position to check if two boards are equivalent under FIDE rules.
  • Added Board::colored_pieces, a shorthand for board.colors(color) & board.pieces(piece).
  • Added BitBoard::is_subset, BitBoard::is_superset, and BitBoard::is_disjoint.

Changed (breaking)

  • BitBoards now operate in a more set-wise manner instead of acting like a u64. Bit operators changed to match set operators.
  • BitBoard::popcnt renamed to BitBoard::len for consistency with other data structures.
  • BoardBuilder's fullmove_number field changed to a u16 for usability reasons.
  • Board's FromStr implementation now parses both FEN and Shredder FEN.

Removed (breaking)

  • BitBoard no longer implements Iterator directly.
  • Sliding move functions are no longer const by default; Use the const variants if required.
  • Unnecessary "try" variants on Board removed; The risk of panicking is accepted when *_unchecked methods are called.


  • Overflow bug in Square::try_offset fixed.
  • FenParseError is no longer unnameable.
  • Fixed incorrect errors being returned in FEN parsing.
  • Fixed some errors not being produced in FEN parsing.