laura_core 0.4.0

A fast and efficient move generator for chess engines.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

# <div align="center"> laura_core</div>


<div  align="center"> 

[![Crates.io Version][crates-badge]][crates-link]
[![License][license-badge]][license-link]

</div>

**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**


```rust
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:

```rust
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.

```rust 
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**

```rust 
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**

```rust 
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:

```rust
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

|Position (Depth)|Black Magics|Black Magics + Native*|BMI2|BMI2 + Native*|
|-|-|-|-|-|
|**Start Position (6)**|410 MN/s|625 MN/s|434 MN/s|640 MN/s|
| **Kiwipete (5)**|531 MN/s|840 MN/s|564 MN/s|910 MN/s|

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

## Changelog


All notable changes are documented in the [CHANGELOG][changelog-link].

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

## **License**


This project is licensed under **GPLv3**. See the [LICENSE][license-link] file for details.

[changelog-link]:https://github.com/hanstibberio/laura_core/blob/main/CHANGELOG.md

[license-link]:https://github.com/hanstibberio/laura_core/blob/main/LICENSE

[license-badge]:https://img.shields.io/github/license/hanstibberio/laura_core?label=license&color=success

[crates-link]:https://crates.io/crates/laura_core

[crates-badge]:https://img.shields.io/crates/v/laura_core