♟️🤖 ChessKitEngine

A Swift package for the following chess engines:

chesskit-engine implements the Universal Chess Interface protocol for communication between chess engines and user interfaces built with Swift.

For a related Swift package that manages chess logic, see chesskit-swift.

Usage

1. Add chesskit-engine as a dependency

   • in an app built in Xcode,
   • or as a dependency to another Swift Package.

2. Next, import ChessKitEngine to use it in Swift code:

import ChessKitEngine

// ...

⚠️ Be sure to check the Neural Networks section below for important setup details.

Features

• Initialize an engine and set response stream

// create Stockfish engine
let engine = Engine(type: .stockfish)

// set response stream, called when engine issues responses
for await response in await engine.responseStream! {
    print(response)
}

// start listening for engine responses
engine.start()

• Send UCI protocol commands

// check that engine is running before sending commands
guard await engine.isRunning else { return }

// stop any current engine processing
await engine.send(command: .stop)

// set engine position to standard starting chess position
await engine.send(command: .position(.startpos))

// start engine analysis with maximum depth of 15
await engine.send(command: .go(depth: 15))

• Update engine position after a move is made

// FEN after 1. e4
let newPosition = "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1"

await engine.send(command: .stop)
await engine.send(command: .position(.fen(newPosition)))
await engine.send(command: .go(depth: 15))

• Receive engine's analysis of current position

// responseStream is called whenever the engine publishes a response
for await response in await engine.responseStream! {
    switch response {
    case let .info(info):
        print(info.score)   // engine evaluation score in centipawns
        print(info.pv)      // array of move strings representing best line
    default:
        break
    }
}

• Terminate engine communication

// stop listening for engine responses
await engine.stop()

• Enable engine response logging

// log engine commands and responses to the console
engine.setLoggingEnabled(true)

// Logging is off by default since engines can be very
// verbose while analyzing positions and returning evaluations.

Neural Networks

Both Stockfish 17 and LeelaChessZero 0.31.1 require neural network files to be provided to the engine for computation. In order to keep the package size small and allow for the greatest level of flexibility, these neural network files are not bundled with the package. Therefore they must be added to the app (either in the bundle or manually by a user) and then provided to the engine at runtime.

They can be provided to the engine using the .setoption(id:value:) UCI commands included in chesskit-engine.

For example:

// Stockfish
await engine.send(command: .setoption(id: "EvalFile", value: fileURL))
await engine.send(command: .setoption(id: "EvalFileSmall", value: smallFileURL))

// Lc0
await engine.send(command: .setoption(id: "WeightsFile", value: fileURL))

The following details the recommended files for each engine and where to obtain them.

Stockfish

• "EvalFile": nn-1111cefa1111.nnue (download here)
• "EvalFileSmall": nn-37f18f62d772.nnue (download here)
• Other files from https://tests.stockfishchess.org can be used if desired.

LeelaChessZero

⚠️ There are currently some performance issues with lc0 in chesskit-engine (PR's are welcome!).

• "WeightsFile": 192x15_network (download here)
• Other files can be obtained here or here.

Supported Engines

The following engines are currently supported:

	Engine	Version	License	Options Reference
	Stockfish	17	GPL v3	🔗
	lc0	0.31.1	GPL v3	🔗

License

ChessKitEngine is distributed under the MIT License.