I have Stockfish compiled on my machine. Instead of just running the Stockfish program in the terminal, is it possible to interact with it in a separate program?

For example, some basic things I might want to do:

  • Create a position object from a FEN.
  • Get an evaluation from the position object (limiting with depth or time).
  • Return an array of positions for all the legal moves from the position.

These are just some very basic examples. Can anyone supply some code snippets for these instructions? I'm really struggling to find any helpful documentation.

EDIT: It looks like this really has a two part solution. The first is piping the input/output to some external program. The second is understanding the UCI protocol to perform what I want to do. Does anyone know the UCI protocol for getting all of the possible moves/positions from a given position? Also, it looks like the 'eval' command only gives a static evaluation of a position (i.e. no consideration of the future). Is there anyway to retrieve a time/depth based evaluation as well?

5 Answers 5


I think you're talking about how to fork a process for the engine and how to use it for the UCI protocol.

What you need to do is:

  1. Fork a new child process for the Stockfish engine
  2. Send and receive UCI commands to/from the engine
  3. Parse the UCI commands yourself

Do you want to study existing source code? Look at:


Download Chess Game Analyzer, it's a simple Python script for automatic annotation.

When you have the source code, look at the the following:

 p = subprocess.Popen(engineName, stdin=subprocess.PIPE,

This line creates a new process for the engine, where engineName is the path of the engine executive.


This line sends the uci command to the engine.

for eline in iter(p.stdout.readline, '')

This line parses a UCI response.

  • How do you view the source code? It looks like you can only get the .rar from that download link. Is there a git repository somewhere for viewing the source code?
    – Dan
    Oct 23, 2016 at 5:22
  • @Dan Download the archive and extract it. You'll find a Python script file. It's not on Github.
    – SmallChess
    Oct 23, 2016 at 5:23

As for the first part, I have been using Perl and the IPC::Open2 package successfully for running Stockfish programmatically. http://perldoc.perl.org/IPC/Open2.html

As for the UCI way to "get all possible moves", you need to set the "multiPV" parameter to some large value (99?), causing the engine to calculate and report a value for every possible move.

As for making the engine calculate (and report), you use the "go" command.

Try it first interactively from the console to get an idea of what the output looks like, so you can intelligently parse it with your program.


Can anyone supply some code snippets for these instructions? I'm really struggling to find any helpful documentation.

Since you say you need to manipulate chess data structures programmatically, you might find the kind of specific programming guidance you want at the Chess Programming Wiki.

It links to the Universal Chess Interface standard, which Stockfish uses to interface to the chess GUI or other program you're using/writing.


The easiest way is to use the python-chess library.

First, download Stockfish from here and unzip it.

Second, install the library with pip install chess

Then follow the example of the engine communication page:

import chess
import chess.engine

engine = chess.engine.SimpleEngine.popen_uci(r"C:\Users\xxxxx\Downloads\stockfish_14_win_x64\stockfish_14_win_x64_avx2.exe")

board = chess.Board()
while not board.is_game_over():
    result = engine.play(board, chess.engine.Limit(time=0.1))


engine.analyze() will give you more information.

import chess
import chess.engine

engine = chess.engine.SimpleEngine.popen_uci("/usr/bin/stockfish")

board = chess.Board()
info = engine.analyse(board, chess.engine.Limit(time=0.1))
print("Score:", info["score"])
# Score: PovScore(Cp(+20), WHITE)

board = chess.Board("r1bqkbnr/p1pp1ppp/1pn5/4p3/2B1P3/5Q2/PPPP1PPP/RNB1K1NR w KQkq - 2 4")
info = engine.analyse(board, chess.engine.Limit(depth=20))
print("Score:", info["score"])
# Score: PovScore(Mate(+1), WHITE)


The Board class constructor accepts a fen= parameter to set a custom FEN.

Use board.legal_moves to get a list of all legal moves from the current position.


As of June 24, 2021 when I am drafting this answer, I can guarantee to anyone that the above accepted answer is no longer true. The above provided ".zip" file no longer works. Hence, I seek and I found.

The optimal way is here. It is fully programmable, even your grandma can do it.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.