Internal API Reference

Transposition table entry.

• key: Zobrist hash of the position (for collision checking)
• value: evaluation score
• depth: search depth at which this value was computed
• node_type: type of node (EXACT, LOWERBOUND, UPPERBOUND)
• best_move: best move found from this position

_filter_legal_moves!(board, pseudo, start, stop, moves, n_moves)

Filters pseudo-legal moves into legal moves, avoiding full make/undo for moves that clearly cannot expose the king.

Clear bit at square sq.

compute_eval_and_phase(board::Board) -> (Int, Int)

Compute the evaluation score (from White's perspective) and the game phase value from scratch for a given board.

Count the number of bits set in a UInt64.

Reconstruct the principal variation (PV) from the transposition table

file_rank(sq) -> (Int, Int)

Return file (1..8) and rank (1..8) for a square index

Try to find a magic number for a given square.

• sq: square index 0–63
• masks: precomputed mask table (bishop or rook)
• attack_fn: function (sq, occ) → attacks
• tries: number of random candidates to attempt

Flip a piece-square table vertically (white → black perspective). Input is a 64-element vector (row-major, starting at A8). Returns a new 64-element vector with ranks mirrored.

Compute magic numbers for all squares.

• masks: precomputed mask table (bishop or rook)
• attack_fn: function (sq, occ) → attacks

Generate pseudo-legal pawn moves in-place

• board: Board struct
• moves: preallocated buffer to append moves

Returns: number of moves added

Generate pseudo-legal pawn moves for the side to move

• board: Board struct

Returns: Vector of Move

Check for fifty-move rule

• board: Board struct

Returns: Bool

is_insufficient_material(board::Board) -> Bool

Check for insufficient material to mate

• board: Board struct

Check for threefold repetition

• board: Board struct

Returns: Bool

king_square(board::Board, side::Side) -> Int

Get the square index of the king for the given side

• board: Board struct
• side: Side (WHITE or BLACK)

Returns: Int (square index 0..63)

Apply a null move (pass) to the board, modifying it in place. Used for null-move pruning.

move_ordering_score(board::Board, m::Move, ply::Int)

Heuristic to score moves for ordering:

• Promotions are prioritized highest.
• Captures are prioritized higher.
• Moves giving check are prioritized.
• Quiet moves get a lower score.

next_square(sq::Int, dir::Tuple{Int,Int}) -> Union{Int,Nothing}

Returns the next square index in direction dir = (df, dr) from sq. Returns nothing if it goes off-board.

occupancy(board::Board) -> UInt64

Returns a bitboard of all occupied squares.

Generate all possible occupancy bitboards for the given mask

piece_at(board::Board, sq) -> Int

Return the piece type at a given square (0..63) using bitboards.

piece_from_symbol(c::AbstractChar, side::Symbol)

Return the piece constant corresponding to promotion symbol c and the moving side (:white or :black).

Return the PSQT value of a piece on a given square.

• piece: Piece.WPAWN..Piece.BKING
• square: 0..63 (a1=0, h8=63)
• phase: Int (0..MAX_PHASE)

ray_between(board, king_sq::Int, from_sq::Int) -> Bool

Returns true if moving a piece from from_sq could open a sliding attack (rook, bishop, queen) towards the king at king_sq.

Set bit at square sq.

Generic sliding attack generator.

• sq: square index
• occ: occupancy bitboard
• directions: list of (df, dr) directions

Generic sliding mask generator.

• sq: square index (0..63)
• directions: list of (df, dr) directions

square_attacked(board, sq, attacker) -> Bool

Check if a square is attacked by the given side.

• board: Board struct
• sq: Int (square index 0..63)
• attacker: Side (WHITE or BLACK)

Returns: Bool

Map algebraic notation (e.g. 'e3') → square index (0..63).

Map (file, rank) → square index (0..63). file=1→a, rank=1→1.

Store a killer move for the given ply. Only quiet moves (non-captures) are stored.

• m: the move to store
• ply: the current ply

Check if bit at square sq is set.

Get index in transposition table from hash.

Look up a position in the transposition table.

• hash: Zobrist hash of the position
• depth: current search depth
• α: alpha value
• β: beta value

Returns a tuple (value, best_move, hit) where hit is true if a valid entry was found.

Store an entry in the transposition table.

Undo a null move, restoring the previous board state.