Laura-Core

Laura-Core a fast and efficient move generator for chess engines.

Features

• Bitboards for efficient board representation.
• Zobrist Hashing
• Black Magic Bitboards for rapid move generation of rooks, bishops, and queens.
• PEXT Bitboards as an alternative for efficient sliding piece move generation.
• Supports full legal move generation or selective move filtering (quiet or tactical moves)
• FEN support: Initialize the board from a FEN string.
• Move execution to update the board state dynamically.
• Null move support for search optimizations like null move pruning.
• UCI move execution: Apply moves directly from a UCI-compliant string.
• Fully #![no_std] compatible

Compilation Recommendations

If your processor supports BMI2 (e.g., Intel Haswell (2013+) or AMD Zen 3 (Nov 2020+)), it is recommended to compile with RUSTFLAGS="-C target-cpu=native" and enable the bmi2 feature for better performance.

Laura-Core provides a feature called bmi2, which enables the use of the pext instruction for more efficient bit manipulation.

For older processors without BMI2 support, only RUSTFLAGS="-C target-cpu=native" should be used, as the bmi2 feature will not work on unsupported hardware.

Usage

Setting up the initial board

use laura_core::Board;

let board: Board = Board::default();
assert_eq!(board.to_fen(), "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")

Initialize a board from a FEN string

You can create a Board from a FEN (Forsyth-Edwards Notation) string using the FromStr trait:

use std::str::FromStr;
use laura_core::Board;

let fen: &str = "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1";
let board: Board = Board::from_str(fen).unwrap();
assert_eq!(board, Board::kiwipete());

Generate all legal moves

To generate moves from a given position, use the gen_moves function along with one of the filtering move types

• AllMoves: Generates all legal moves.
• QuietMoves: Generates only quiet moves (non-capturing moves).
• TacticalMoves: Generates tactical moves (captures and queen promotions).

Example: Generating all legal moves

This example starts from the default position and generate all legal moves.

use laura_core::{gen_moves, Board, MoveList, AllMoves};

let board: Board = Board::default();
let moves: MoveList = gen_moves::<AllMoves>(&board);
assert_eq!(moves.len(), 20);

Example: Generating only quiet moves

use laura_core::{gen_moves, Board, MoveList, QuietMoves};

let board: Board = Board::kiwipete();
let moves: MoveList = gen_moves::<QuietMoves>(&board);
assert_eq!(moves.len(), 40);

Example: Generating only tactical moves

use laura_core::{gen_moves, Board, MoveList, TacticalMoves};

let board: Board = Board::kiwipete();
let moves: MoveList = gen_moves::<TacticalMoves>(&board);
assert_eq!(moves.len(), 8);

Execute moves

You can apply a move to the board using UCI (Universal Chess Interface) notation:

use laura_core::Board;

let board: Board = Board::default();
let new: Board = board.make_uci_move("e2e4").unwrap();
assert_eq!(new.to_fen(), "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1");

This executes the move e2e4 (pawn to e4) and asserts the updated board position.

Benchmarks

Test system: AMD Ryzen 5 5600G (3.9 GHz), 32 GB DDR4 3200 MHz, Windows 10

* Compiled with RUSTFLAGS="-C target-cpu=native" for hardware-specific optimization.

Changelog

All notable changes are documented in the CHANGELOG.

For details on the latest updates, bug fixes, and improvements, check the full changelog.

License

This project is licensed under GPLv3. See the LICENSE file for details.