A fast Connect-4 Solver for Python & C++

These details have been verified by PyPI

Project links

GitHub Statistics

Maintainers

These details have not been verified by PyPI

Project description

BitBully: A fast and perfect-playing Connect-4 Agent for Python 3 & C/C++

GitHub Repo stars GitHub forks Python Python Docs PyPI - Version PyPI - Downloads PyPI - License Wheels Doxygen CMake Build Buy Me a Coffee

BitBully is a high-performance Connect-4 solver implemented in C++ with Python bindings, built around advanced search algorithms and highly optimized bitboard operations. It is designed for efficient game solving and analysis, targeting both developers interested in performance-critical implementations and researchers working on game-tree search.

BitBully evaluates millions of positions per second in pure C++ and supports constant-time opening-book lookups for early-game positions. Even without opening databases, it can solve the entire game in under 200 seconds on relatively modest hardware.

Connect4 opening Connect4 mid-game Connect4 victory

From opening to victory: three key stages of a Connect 4 match — early game, mid-game tension, and the final winning position.

Quickstart

Installation

pip install bitbully

Usage

import bitbully as bb

agent = bb.BitBully()
board = bb.Board()

while not board.is_game_over():
    board.play(agent.best_move(board))

print(board)
print("Winner:", board.winner())

Features
Who is this for?
Quickstart
- Installation
- Usage
Installation
- Prerequisites
Build and Install
- From PyPI (Recommended)
Python API Docs
Usage
Benchmarking
Advanced Build and Install
- From Source
- Building Static Library with CMake
Contributing & Development
License
Contact
Further Resources
Acknowledgments

Features

Fast Solver: Implements MTD(f) and null-window search algorithms for Connect-4.
Bitboard Representation: Efficiently manages board states using bitwise operations.
Advanced Features: Includes transposition tables, threat detection, and move prioritization.
Python Bindings: Exposes core functionality through the bitbully_core Python module using pybind11.
Cross-Platform: Build and run on Linux, Windows, and macOS.
Open-Source: Fully accessible codebase for learning and contribution.

Who is this for?

Just want to play or analyze Connect-4 in Python? → Read Quickstart + Usage (High-level Python API)
Interested in performance, algorithms, or C++ integration? → See Low-level C++ bindings (advanced)
Working on research, solvers, or databases? → See Opening Books and BoardCore

Installation

Prerequisites

Python: Version 3.10 or higher, PyPy 3.10 or higher

Build and Install

From PyPI (Recommended)

The easiest way to install the BitBully package is via PyPI:

pip install bitbully

This will automatically download and install the pre-built package, including the Python bindings.

Python API Docs

Please refer to the docs here: https://markusthill.github.io/BitBully/.

The docs for the opening databases can be found here: https://markusthill.github.io/bitbully-databases/

Usage

⚠️ Note bitbully_core exposes low-level C++ bindings intended for advanced users. Most users should use the high-level bitbully Python API with the classes Board and BitBully.

BitBully currently supports standard Connect-4 (7 columns × 6 rows). Generalized board sizes are not supported.

🚀 BitBully: Getting Started with a Jupyter Notebook

This notebook introduces the main building blocks of BitBully:

Board: represent and manipulate Connect Four positions
BitBully: analyze positions and choose strong moves

All examples are designed to be copy-pasteable and easy to adapt for your own experiments.

Jupyter Notebook: notebooks/getting_started.ipynb

🎮 Play a Game of Connect-4 with a simple Jupyter Notebook Widget

BitBully includes an interactive Connect-4 widget for Jupyter built with ipywidgets + Matplotlib. GuiC4 renders a 6x7 board using image sprites, supports move evaluation, provides undo/redo, can trigger a computer move using the BitBully engine (optionally with an opening book database). It's intended for quick experimentation and demos inside notebooks (best with %matplotlib ipympl).

Jupyter Notebook: notebooks/game_widget.ipynb

High-level Python API (recommended)

Empty board + play moves incrementally

import bitbully as bb

board = bb.Board()
assert board.play(3)          # single move (int)
assert board.play([2, 4, 3])  # multiple moves (list)
assert board.play("001122")   # multiple moves (string)

print(board)

Initialize directly from a move sequence

import bitbully as bb

board_a = bb.Board([3, 3, 3, 1, 1])
board_b = bb.Board("33311")

assert board_a == board_b
print(board_a)

Create positions (moves, strings, arrays) and round-trip them

import bitbully as bb

# From a move list
b1 = bb.Board([3, 3, 3, 1, 1])

# From a compact move string
b2 = bb.Board("33311")

assert b1 == b2
print(b1)

# From a 2D array (row-major 6x7 or column-major 7x6 both work)
arr = b1.to_array()  # default: column-major 7x6
b3 = bb.Board(arr)

assert b1 == b3

Legal moves and remaining moves

import bitbully as bb

board = bb.Board("33333111")

print(board.legal_moves())                 # all legal columns
print(board.legal_moves(order_moves=True)) # ordered (center-first)
print("Moves left:", board.moves_left())
print("Tokens:", board.count_tokens())

Some board utilities

import bitbully as bb

board = bb.Board("332311")
print(board)

print("Can win next (any):", board.can_win_next())
print("Can win next in col 4:", board.can_win_next(4))

assert board.play(4)  # play winning move
print(board)

print("Has win:", board.has_win())
print("Game over:", board.is_game_over())
print("Winner:", board.winner())  # 1

Solver Quickstart: evaluate a position and pick a move

import bitbully as bb

agent = bb.BitBully()          # loads default opening book ("12-ply-dist")
board = bb.Board()             # empty board

print(board)

scores = agent.score_all_moves(board)
print("Move scores:", scores)

best_col = agent.best_move(board)
print("Best move:", best_col)

Play a small game loop (agent vs. itself)

import bitbully as bb

agent = bb.BitBully()
board = bb.Board()

while not board.is_game_over():
    col = agent.best_move(board, tie_break="random")
    assert board.play(col)

print(board)
print("Winner:", board.winner())  # 1, 2, or None for draw

Tie-breaking strategies for `best_move`

import bitbully as bb
import random

agent = bb.BitBully()
board = bb.Board("341")  # arbitrary position

print(board)

print("Center tie-break:", agent.best_move(board, tie_break="center"))
print("Leftmost tie-break:", agent.best_move(board, tie_break="leftmost"))

rng = random.Random(42) # optional own random generator
print("Random tie-break (seeded):", agent.best_move(board, tie_break="random", rng=rng))

Different Search Algorithms

import bitbully as bb

agent = bb.BitBully()
board, _ = bb.Board.random_board(n_ply=14, forbid_direct_win=True)

s1 = agent.mtdf(board)
s2 = agent.negamax(board)
s3 = agent.null_window(board)

assert s1 == s2 == s3
print("Score:", s1)

Low-level C++ bindings (advanced)

Use the BitBullyCore and BoardCore classes directly in Python:

BoardCore Examples

The low-level BoardCore API gives you full control over Connect-4 positions: you can play moves, generate random boards, mirror positions, and query win conditions or hashes.

Create and Print a Board

import bitbully.bitbully_core as bbc

board = bbc.BoardCore()
print(board)          # Human-readable 7x6 board
print(board.movesLeft())   # 42 on an empty board
print(board.countTokens()) # 0 on an empty board

Play Moves and Check for Winning Positions

import bitbully.bitbully_core as bbc

board = bbc.BoardCore()

# Play a small sequence of moves (columns 0–6)
for col in [3, 2, 3, 2, 3, 4, 3]:
    assert board.play(col)

print(board)

# Check if the side to move has an immediate winning move
print(board.canWin())      # False
print(board.hasWin())      # True, since the last move created 4-in-a-row

You can also check if a specific column is a winning move:

board = bbc.BoardCore()
board.setBoard([3, 3, 3, 3, 2, 2, 4, 4])

print(board.canWin())  # True
print(board.canWin(1))  # True  – playing in column 1 wins
print(board.canWin(3))  # False – no win in column 3

Set a Board from a Move List or Array

import bitbully.bitbully_core as bbc

board = bbc.BoardCore()

# From a move sequence (recommended)
assert board.setBoard([0, 1, 2, 3, 3, 2, 1, 0])

# Convert to 7x6 array (columns × rows)
array = board.toArray()
print(len(array), len(array[0]))  # 7 x 6

# From a 7x6 array of tokens (1 = Yellow, 2 = Red)
array_board = [[0 for _ in range(6)] for _ in range(7)]
array_board[3][0] = 1  # Yellow in center column bottom row
b2 = bbc.BoardCore()
assert b2.setBoard(array_board)

Generate Random Boards

import bitbully.bitbully_core as bbc

board, moves = bbc.BoardCore.randomBoard(10, True)

print(board)   # Random, valid board
print(moves)   # List of 10 column indices
print(board.canWin())  # Usually False for random boards in this setup

Mirroring Boards and Symmetry

import bitbully.bitbully_core as bbc

board = bbc.BoardCore()
board.setBoard([0, 1, 2])      # Left side

mirrored = board.mirror()      # Mirror around center column
print(board)
print(mirrored)

# Double-mirroring returns the original position
assert board == mirrored.mirror()

Hashing, Equality, and Copies

import bitbully.bitbully_core as bbc

b1 = bbc.BoardCore()
b2 = bbc.BoardCore()

moves = [0, 1, 2, 3]
for m in moves:
    b1.play(m)
    b2.play(m)

assert b1 == b2
assert b1.hash() == b2.hash()
assert b1.uid() == b2.uid()

# Copying a board
b3 = b1.copy()           # or bbc.BoardCore(b1)
assert b3 == b1

b3.play(4)               # Modify the copy
assert b3 != b1
assert b3.hash() != b1.hash()

These examples are based on the internal test suite and show typical ways of interacting with BoardCore programmatically.

BitBullyCore: Connect-4 Solver Examples

The BitBullyCore module provides a high-performance Connect-4 solver written in C++ and exposed to Python. You can evaluate positions, score all legal moves, or run the full MTD(f) search.

Solve a Position with MTD(f)

import bitbully.bitbully_core as bbc

# Construct a position: alternate moves into the center column
board = bbc.BoardCore()
for _ in range(6):
    board.play(3)  # Column 3

solver = bbc.BitBullyCore()
score = solver.mtdf(board, first_guess=0)

print("Best score:", score)

mtdf returns an integer score from the perspective of the side to move (positive = winning, negative = losing).

Score All Moves in a Position

scoreMoves(board) returns a list of 7 integers: the evaluated score for playing in each column (0–6). Illegal moves (full columns) are still included in the list.

import bitbully.bitbully_core as bbc

board = bbc.BoardCore()
board.setBoard([3, 4, 1, 1, 0, 2, 2, 2])

solver = bbc.BitBullyCore()
scores = solver.scoreMoves(board)

print("Move scores:", scores)
# Example output:
# [-3, -3, 1, -4, 3, -2, -2]

Using the Solver in a Loop (Move Selection)

import bitbully.bitbully_core as bbc
import time

board = bbc.BoardCore()
solver = bbc.BitBullyCore()

for move in [3, 4, 1, 1, 0, 2, 2, 2]:  # Example opening
    board.play(move)

start = time.perf_counter()
scores = solver.scoreMoves(board)
best_move = max(range(7), key=lambda c: scores[c])
print(f"Time: {round(time.perf_counter() - start, 2)} seconds!")
print("Scores:", scores)
print("Best move suggestion:", best_move)
# best move is into column 4

Further Examples using the BitBully Solver

You can initialize a board using an array with shape (7, 6) (columns first) and solve it:

from bitbully import bitbully_core

# Define a Connect-4 board as an array (7 columns x 6 rows)
# You may also define the board using a numpy array if numpy is installed
# 0 = Empty, 1 = Yellow, 2 = Red
# Here, the left column represents the bottom row of the board
board_array = [
    [0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0],
    [1, 2, 1, 2, 1, 0],
    [0, 0, 0, 0, 0, 0],
    [2, 1, 2, 0, 0, 0],
    [0, 0, 0, 0, 0, 0]
]

# Convert the array to the BoardCore board
board = bitbully_core.BoardCore()
assert board.setBoard(board_array), "Invalid board!"

print(board)

# Solve the position
solver = bitbully_core.BitBullyCore()
score = solver.mtdf(board, first_guess=0)
print(f"Best score for the current board: {score}") # expected score: 1

Run the Bitbully solver with an opening book (here: 12-ply opening book with winning distances):

from bitbully import bitbully_core as bbc
import bitbully_databases as bbd
import importlib.resources

db_path = bbd.BitBullyDatabases.get_database_path("12-ply-dist")
bitbully = bbc.BitBullyCore(db_path)
b = bbc.BoardCore()  # Empty board
bitbully.scoreMoves(b)  # expected result: [-2, -1, 0, 1, 0, -1, -2]

Further Usage Examples for BitBully Core

Create all Positions with (up to) n tokens starting from Board b:

from bitbully import bitbully_core as bbc

b = bbc.BoardCore()  # empty board
board_list_3ply = b.allPositions(3, True)  # All positions with exactly 3 tokens
len(board_list_3ply)  # should be 238 according to https://oeis.org/A212693

Opening Book Examples

BitBully Databases provide fast lookup tables (opening books) for Connect-4, allowing you to query evaluated positions, check if a board is known, and retrieve win/loss/distance values.

Load an Opening Book

import bitbully_databases as bbd
import bitbully.bitbully_core as bbc

# Load the 8-ply opening book (no distances)
db_path = bbd.BitBullyDatabases.get_database_path("8-ply")
book = bbc.OpeningBookCore(db_path, is_8ply=True, with_distances=False)

print(book.getBookSize())  # e.g., 34515
print(book.getNPly())      # -> 8

Accessing Entries

Each entry consists of (key, value) where:

key is the Huffman-encoded board state
value is the evaluation (win/loss/draw or distance)

k, v = book.getEntry(0)
print(k, v)

Evaluating a Board Position

import bitbully.bitbully_core as bbc

board = bbc.BoardCore()
board.setBoard([2, 3, 3, 3, 3, 3, 5, 5])  # Sequence of column moves

value = book.getBoardValue(board)
print("Evaluation:", value)

Check Whether a Position Is in the Opening Book

The books only contain one variant for mirror-symmetric positions:

board = bbc.BoardCore()
board.setBoard([1, 3, 4, 3, 4, 4, 3, 3])

print(book.isInBook(board))              # e.g., False
print(book.isInBook(board.mirror()))     # e.g., True, checks symmetric position

Benchmarking

This section describes how BitBully was benchmarked against a strong Baseline solver, how the reported numbers were obtained, and how to interpret the reported p-values.

Setup

The benchmark compares BitBully against the Baseline on identical Connect-4 positions, measuring wall-clock solve time per position.

Position generation

For a fixed search depth nply, random but legal Connect-4 positions are generated.
Each position is constructed by playing a random sequence of nply moves from the empty board (non-trivial positions, meaning that they do not contain a winning position for the player to move next.).
The same position is evaluated by both solvers.

Solvers

Opening books are deactivated for both solvers.
BitBully: evaluated using its mtdf search with transposition tables enabled. Transposition Table size: $2^{20}=1,048,576$ entries.
Baseline: evaluated using its standard solve routine, with transposition tables enabled. Transposition Table size: $2^{24}=16,777,216$ entries.
For correctness, both solvers must return the same game-theoretic score; execution aborts if a mismatch occurs.

Timing: Each solver is timed independently on the same board.

Repetitions

For each nply, the experiment is repeated nrepeats times (typically 25–2000, depending on search depth).
In this case, transposition-table resets are enabled to control caching effects.

Aggregation & Reported Metrics

From the recorded timings, the following statistics are computed:

Mean ± Standard Deviation: Arithmetic mean and sample standard deviation of solve times (in seconds).
Speed-up: Speed-up = mean(Baseline) / mean(BitBully). Values > 1 indicate that BitBully is faster on average.
Paired Statistical Test (p-value):A paired Wilcoxon signed-rank test is applied to the timing pairs.

Statistical Significance & p-Value Interpretation

To assess whether observed speed differences are statistically meaningful, a Wilcoxon signed-rank test is used:

Why Wilcoxon?

Timing distributions are often non-Gaussian and heavy-tailed.
Measurements are paired (same position, two solvers).
Wilcoxon is non-parametric and robust to outliers.

Test definition

Null hypothesis (H₀): BitBully is not faster than Baseline.
Alternative hypothesis (H₁): BitBully is faster than Baseline.

p-value meaning

The p-value is the probability of observing the measured (or more extreme) speed advantage if H₀ were true.
Very small p-values indicate overwhelming evidence that BitBully is faster.
Values ≥ 0.05 indicate that the observed difference is not statistically significant at the 5% level.

Notes & Caveats

We left the size of the transposition table for Baseline as-is, likely giving it a slight advantage over BitBully.
Benchmarks measure solve time, not node count or memory usage.
Results might depend on compiler optimizations, hardware, and cache behavior.
Small p-values are expected for large nrepeats when even modest speed differences are consistent.

The full benchmark code and analysis notebook are included in the repository for reproducibility.

Machine Setup

FUJITSU LIFEBOOK N532 from 2012.

WSL Setup:

+------------------+-------------------------------------------+
| OS               | Linux 6.6.87.2-microsoft-standard-WSL2    |
| Distribution     | Ubuntu 22.04.4 LTS                        |
| Architecture     | x86_64                                    |
| CPU              | x86_64                                    |
| Cores (phys/log) | 2 / 4                                     |
| RAM              | 8 GiB                                     |
| GPU              | None / Unknown                            |
| Python           | CPython 3.11.0rc1                         |
| Compiler         | gcc (Ubuntu 13.1.0-8ubuntu1~22.04) 13.1.0 |
| Fingerprint      | ea68f7b392a21300                          |
+------------------+-------------------------------------------+

Output of systeminfo on Windows CMD (reformatted):

┌────────────────────────┬────────────────────────────────────────────────┐
│ Manufacturer / Model   │ FUJITSU LIFEBOOK N532                          │
│ System Type            │ x64-based PC                                   │
│ BIOS                   │ AMI 1.12A (02.07.2012)                         │
├────────────────────────┼────────────────────────────────────────────────┤
│ Operating System       │ Windows 10 Pro                                 │
│ OS Version             │ 10.0.19045 (Build 19045)                       │
│ Install Date           │ 25.08.2020                                     │
│ Time Zone              │ UTC+01:00 (Central Europe)                     │
├────────────────────────┼────────────────────────────────────────────────┤
│ CPU                    │ Intel Core (Family 6, Model 58)                │
│ Nominal Frequency      │ ~2.9 GHz                                       │
│ CPU Count              │ 1 physical processor                           │
├────────────────────────┼────────────────────────────────────────────────┤
│ Physical Memory        │ 16 GB RAM                                      │
│ Available Memory       │ ~6 GB                                          │
│ Virtual Memory (Max)   │ ~20 GB                                         │
├────────────────────────┼────────────────────────────────────────────────┤
│ Virtualization         │ Hypervisor detected (Hyper-V / WSL active)     │
└────────────────────────┴────────────────────────────────────────────────┘

Results (BitBully vs Baseline)

Times in seconds: (Mean ± Std)

nply	nrepeats	BitBully [s]	Baseline [s]	Speed-up	p-value	Significant
(empty board) 0	25	197.5023 ± 7.8470	386.3228 ± 17.3956	1.96	2.98e-08	*
1	50	117.0179 ± 42.2797	151.0143 ± 55.6900	1.29	4.73e-05	*
2	250	59.7311 ± 60.7071	68.5259 ± 68.1356	1.15	0.000299	*
3	500	27.6295 ± 27.4619	31.9983 ± 33.9760	1.16	2.7e-10	*
4	500	11.0583 ± 12.9979	15.5146 ± 20.8694	1.4	2.33e-37	*
5	500	4.1296 ± 5.0585	5.8230 ± 7.2602	1.41	1.04e-47	*
6	1000	2.1579 ± 2.8749	3.2826 ± 4.6897	1.52	5.26e-92	*
7	1000	0.9930 ± 1.2125	1.4714 ± 2.2783	1.48	2.52e-72	*
8	1000	0.5269 ± 0.6483	0.8201 ± 1.2421	1.56	3.44e-62	*
9	1000	0.2537 ± 0.3188	0.3709 ± 0.6311	1.46	3.54e-41	*
10	1000	0.1523 ± 0.1849	0.2035 ± 0.2979	1.34	4.68e-20	*
11	1000	0.0808 ± 0.1201	0.1102 ± 0.1997	1.36	8.42e-17	*
12	1000	0.0487 ± 0.0761	0.0601 ± 0.1179	1.23	0.00366	*
13	1000	0.0254 ± 0.0429	0.0293 ± 0.0525	1.15	0.0028	*
14	2000	0.0176 ± 0.0286	0.0180 ± 0.0325	1.02	1
15	2000	0.0110 ± 0.0204	0.0104 ± 0.0221	0.94	1
16	2000	0.0065 ± 0.0131	0.0060 ± 0.0136	0.93	1

Interpretation of the Benchmarking Results

The benchmarking results highlight two distinct performance regimes: early-game (low ply) and mid-to-late-game (higher ply) positions.

Early game (0–6 ply). Starting from an empty board (nply = 0), BitBully requires on average ~198 seconds solving the whole game, while the Baseline solver needs ~386 seconds, resulting in an almost 2× speed-up. This gap remains clearly visible up to about 6 ply, where BitBully consistently outperforms the Baseline, with small p-values indicating strong statistical significance. This regime corresponds to the hardest positions in Connect-4: the branching factor is maximal and the solver must explore a large fraction of the game tree. Here, BitBully's search strategy, move ordering, and pruning heuristics pay off most.

Transition region (7–12 ply). As more tokens are placed on the board, the average solve time drops rapidly for both solvers—from seconds to tens of milliseconds. BitBully still maintains a consistent advantage (≈ 1.2×–1.5×), and the differences remain statistically significant. However, the absolute time savings shrink quickly: improving from 0.8 s to 0.5 s is far less noticeable than shaving minutes off an empty-board solve.

Late game (≥14 ply). Beyond roughly 14 ply, solve times become negligible (on the order of a few milliseconds or less) for both solvers. In this region, many positions are tactically forced, shallow, or immediately decidable via pruning. Measured differences are dominated by some BitBully overhead and partially by noise, and no statistically significant advantage can be established.

Advanced Build and Install

Prerequisites

Python: Version 3.10 or higher
CMake: Version 3.15 or higher
C++ Compiler: A compiler supporting C++-17 (e.g., GCC, Clang, MSVC)
Python Development Headers: Required for building the Python bindings

From Source

Clone the repository:

git clone https://github.com/MarkusThill/BitBully.git
cd BitBully
git submodule update --init --recursive # – Initialize and update submodules.

Build and install the Python package:
```
pip install .
```

Building Static Library with CMake

Create a build directory and configure the project:

mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release

Build the a static library:
```
cmake --build . --target cppBitBully
```

Contributing & Development

Whether you're fixing a bug, optimizing performance, or extending BitBully with new features, contributions are highly appreciated. The full development guide provides everything you need to work on the project efficiently:

📘 Complete Development Documentation https://markusthill.github.io/BitBully/develop/

It covers all essential workflows, including:

Repository setup: cloning, submodules, virtual environments
Development environment: installing dev dependencies, using editable mode
Code quality tools: ruff, mypy/pyrefly, clang-format, pre-commit, commitizen
Building the project: local wheels, CMake, cibuildwheel, sdist
Testing: running pytest, filtering tests, coverage, CI integration
Release workflow: semantic versioning, version bumping, tagging, PyPI/TestPyPI publishing
Debugging & tooling: GDB, Doxygen, mkdocs, stub generation for pybind11
Platform notes: Debian/Linux setup, gcov matching, MSVC quirks
Cheatsheets: Git, submodules, CMake, Docker, Ruby/Jekyll, npm, environment management

If you're contributing code, please:

Follow the coding standards and formatting tools (ruff, mypy, clang-format).
Install and run pre-commit hooks before committing.
Write or update tests for all behavioral changes.
Use Commitizen for semantic commit messages and versioning.
Open an issue or discussion for major changes.

Pull requests are welcome — thank you for helping improve BitBully! 🚀

License

This project is licensed under the AGPL-3.0 license.

Contact

If you have any questions or feedback, feel free to reach out:

Web: https://markusthill.github.io
GitHub: MarkusThill
LinkedIn: Markus Thill

Further Ressources

BitBully project summary on blog
BitBully Databases project on GitHub and project summary on my blog
A blog post series on tree search algorithms for Connect-4:
- Initial steps
- Tree search algorithms

Acknowledgments

Many of the concepts and techniques used in this project are inspired by the outstanding Connect-4 solvers developed by Pascal Pons and John Tromp. Their work has been invaluable in shaping this effort:

Project details

These details have been verified by PyPI

Project links

GitHub Statistics

Maintainers

diedackel

These details have not been verified by PyPI

Release history Release notifications | RSS feed

This version

0.0.78

Apr 18, 2026

0.0.77

Apr 12, 2026

0.0.76

Feb 22, 2026

0.0.75

Jan 25, 2026

0.0.74

Dec 30, 2025

0.0.73

Dec 29, 2025

0.0.72

Dec 27, 2025

0.0.71

Dec 26, 2025

0.0.70

Dec 26, 2025

0.0.69

Dec 23, 2025

0.0.58

Nov 16, 2025

0.0.57

Nov 1, 2025

0.0.53

Sep 14, 2025

0.0.45

Aug 13, 2025

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

bitbully-0.0.78.tar.gz (8.1 MB view details)

Uploaded Apr 18, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

bitbully-0.0.78-pp311-pypy311_pp73-win_amd64.whl (491.3 kB view details)

Uploaded Apr 18, 2026 PyPyWindows x86-64

bitbully-0.0.78-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (367.0 kB view details)

Uploaded Apr 18, 2026 PyPymanylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

bitbully-0.0.78-pp311-pypy311_pp73-macosx_11_0_arm64.whl (263.8 kB view details)

Uploaded Apr 18, 2026 PyPymacOS 11.0+ ARM64

bitbully-0.0.78-pp310-pypy310_pp73-win_amd64.whl (490.0 kB view details)

Uploaded Apr 18, 2026 PyPyWindows x86-64

bitbully-0.0.78-pp310-pypy310_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (365.4 kB view details)

Uploaded Apr 18, 2026 PyPymanylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

bitbully-0.0.78-pp310-pypy310_pp73-macosx_11_0_arm64.whl (262.7 kB view details)

Uploaded Apr 18, 2026 PyPymacOS 11.0+ ARM64

bitbully-0.0.78-cp314-cp314-win_amd64.whl (502.6 kB view details)

Uploaded Apr 18, 2026 CPython 3.14Windows x86-64

bitbully-0.0.78-cp314-cp314-musllinux_1_2_x86_64.whl (1.3 MB view details)

Uploaded Apr 18, 2026 CPython 3.14musllinux: musl 1.2+ x86-64

bitbully-0.0.78-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (368.5 kB view details)

Uploaded Apr 18, 2026 CPython 3.14manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

bitbully-0.0.78-cp314-cp314-macosx_11_0_arm64.whl (264.8 kB view details)

Uploaded Apr 18, 2026 CPython 3.14macOS 11.0+ ARM64

bitbully-0.0.78-cp313-cp313-win_amd64.whl (492.6 kB view details)

Uploaded Apr 18, 2026 CPython 3.13Windows x86-64

bitbully-0.0.78-cp313-cp313-musllinux_1_2_x86_64.whl (1.3 MB view details)

Uploaded Apr 18, 2026 CPython 3.13musllinux: musl 1.2+ x86-64

bitbully-0.0.78-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (368.4 kB view details)

Uploaded Apr 18, 2026 CPython 3.13manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

bitbully-0.0.78-cp313-cp313-macosx_11_0_arm64.whl (264.3 kB view details)

Uploaded Apr 18, 2026 CPython 3.13macOS 11.0+ ARM64

bitbully-0.0.78-cp312-cp312-win_amd64.whl (492.6 kB view details)

Uploaded Apr 18, 2026 CPython 3.12Windows x86-64

bitbully-0.0.78-cp312-cp312-musllinux_1_2_x86_64.whl (1.3 MB view details)

Uploaded Apr 18, 2026 CPython 3.12musllinux: musl 1.2+ x86-64

bitbully-0.0.78-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (368.9 kB view details)

Uploaded Apr 18, 2026 CPython 3.12manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

bitbully-0.0.78-cp312-cp312-macosx_11_0_arm64.whl (264.2 kB view details)

Uploaded Apr 18, 2026 CPython 3.12macOS 11.0+ ARM64

bitbully-0.0.78-cp311-cp311-win_amd64.whl (491.8 kB view details)

Uploaded Apr 18, 2026 CPython 3.11Windows x86-64

bitbully-0.0.78-cp311-cp311-musllinux_1_2_x86_64.whl (1.3 MB view details)

Uploaded Apr 18, 2026 CPython 3.11musllinux: musl 1.2+ x86-64

bitbully-0.0.78-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (366.3 kB view details)

Uploaded Apr 18, 2026 CPython 3.11manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

bitbully-0.0.78-cp311-cp311-macosx_11_0_arm64.whl (263.9 kB view details)

Uploaded Apr 18, 2026 CPython 3.11macOS 11.0+ ARM64

bitbully-0.0.78-cp310-cp310-win_amd64.whl (490.7 kB view details)

Uploaded Apr 18, 2026 CPython 3.10Windows x86-64

bitbully-0.0.78-cp310-cp310-musllinux_1_2_x86_64.whl (1.3 MB view details)

Uploaded Apr 18, 2026 CPython 3.10musllinux: musl 1.2+ x86-64

bitbully-0.0.78-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (364.5 kB view details)

Uploaded Apr 18, 2026 CPython 3.10manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

bitbully-0.0.78-cp310-cp310-macosx_11_0_arm64.whl (262.8 kB view details)

Uploaded Apr 18, 2026 CPython 3.10macOS 11.0+ ARM64

File details

Details for the file bitbully-0.0.78.tar.gz.

File metadata

Download URL: bitbully-0.0.78.tar.gz
Upload date: Apr 18, 2026
Size: 8.1 MB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/6.1.0 CPython/3.13.12

File hashes

Hashes for bitbully-0.0.78.tar.gz
Algorithm	Hash digest
SHA256	`723165ac42bc08b4a8862e2d580cb951c76a3aeb4fc20a5e2b53abaacf9f1daa`
MD5	`560c62d69a9434027e834545a7a6e2c5`
BLAKE2b-256	`a8f32575e6782360a49f5624c4f6059cccbb3749a312839807daaf24563db5fa`

Algorithm	Hash digest
SHA256	`8207f20573e00752c28ea1c91adfe4dd8b5cb931cc2e2b11955f035c25b652dc`
MD5	`a4342890723adb6f3a821e7ba325aefb`
BLAKE2b-256	`dad468faba5d5700be8a666ff8949e488d5a70749710a3d351fa6cbe416e1928`

Algorithm	Hash digest
SHA256	`ad9f95fd44064502eedba56439f93543a864a8bf9e7f562c2e0b69fcfc166017`
MD5	`a4196dd432d1cf8ac93b31537ce1dd74`
BLAKE2b-256	`4d5fdb5903fa58fb25013b4a89fd45789e94096b0a3e83cd1b80898daea8214d`

Algorithm	Hash digest
SHA256	`29625b0b6e38c4428e03191bf8810d376ed8807792c93839b1654b92da9db1ef`
MD5	`7f7150bb1765842c4a46d740f9ef70f7`
BLAKE2b-256	`a9d4b061abc52db98a8e764201f4715889d802287418605775be0692d1669cc9`

Algorithm	Hash digest
SHA256	`ac3c4fe3a74943ca373af9704fb3c3ea61c87fcf56ab59b444ad8fcc090275dc`
MD5	`be465fcbaf4a80851bc6ca9689f391c3`
BLAKE2b-256	`5f319164cdbcfcc3d13a2de3d7359c5c202053826e05050abf4e2b722b6ae631`

Algorithm	Hash digest
SHA256	`dd428911796a022b53c52e9692ad75a2614fc2d87cdf1f8c6392f573f44a3729`
MD5	`04500da13fcdbcb6b6af39141ff4dc53`
BLAKE2b-256	`0d465802200378b07e4e8e20403ff907e4b96e59991e40eee8ce0c23b12b8137`

Algorithm	Hash digest
SHA256	`45d881d77b1a9ed79a35b78450695be4325cd7864072d236d35ffc4416181cfa`
MD5	`0034fd50dd1297a01792cfd0cdd6aa1d`
BLAKE2b-256	`318950b4aaf44bd65a021a2f9021cdbffe54fde939a7149048de77b352b7c138`

Algorithm	Hash digest
SHA256	`ae6527335457b13ccccadbedab800e48796792cf774f0d7d96dfbdd6531a09b5`
MD5	`513569ffc57a1f9b61f61dad87aa47d4`
BLAKE2b-256	`b35518205f0416b4c4911d87c23cfd73f2d26ba504a49a7f07cb63237d39a97e`

Algorithm	Hash digest
SHA256	`00bc51a9e9e55556b5a2cb745d071806de65349da0a3cb415a18dc7cca3e86e5`
MD5	`d23c03105d33a678962bc8b69f2caa0e`
BLAKE2b-256	`15624eb2fc9e2581c16a7ad5be731a0493c01c6774128b6713720a7a447304b1`

Algorithm	Hash digest
SHA256	`98b4dc23f88fee9c138a6b6fae7a2342b12a67b53c2597ef8ff811a19a51f073`
MD5	`fb1c74111e95aa585ece02fd9b8269de`
BLAKE2b-256	`b7d8c1690e7fd4593f6193245f342cd8ff8af0301fb3c5a67e575d8645599f6f`

Algorithm	Hash digest
SHA256	`c990098428e590879cd82297029d91f8d62de787a41bc593c0595708d10c9464`
MD5	`b19eb76f380842c63d3cdb96154abbb3`
BLAKE2b-256	`9ea3e90b05518e6953e0c19d3c9ffac6bab3300317e69d0244d160cf849b5e7c`

Algorithm	Hash digest
SHA256	`6c075fbfda07387b0414eb737baa0b6c14fa26685ac4b9cc84a5a6d7e732cc5b`
MD5	`ca99b67ba7dea80132ed4a10339c7f32`
BLAKE2b-256	`261c94778d59aae5a5c39884ba4d9a865a2a9a07d9e3e2cb93aaa3bc908b3954`

Algorithm	Hash digest
SHA256	`e16b39b02b7cc94d8ac870e2ab1272e9004015b18ef900e326d793cb140cab6e`
MD5	`653bc50023d8749e852bcf93a7ceb105`
BLAKE2b-256	`9bb72f48bec0523ebc6b24e2a311112d92f7a1a8c4b357f14cfae56d9efe37aa`

Algorithm	Hash digest
SHA256	`5713baf69c1efdb6bef4a1351320b89e85e6654518654e9bacaad557b209d640`
MD5	`a038dfc8426298d160bba8daf0a4a6e7`
BLAKE2b-256	`fdc480c808efe67664b17b6c2fc6ae680de4407f17f26b17a6e8441069e02426`

Algorithm	Hash digest
SHA256	`53d9aa1ccf51a6dc57ad371b55b273f6583427aedac57f727a3ce1e5355686a2`
MD5	`845e396d56df02efb09544fddb5c4f5f`
BLAKE2b-256	`79e006afa0dfa52bac6487d41d16c54cd41d29274e0330593822edf72ee69b8d`

Algorithm	Hash digest
SHA256	`5df218dc3fe7d6826419cc5884b8459bcbb25d0390336d6325e86f77216b845e`
MD5	`4e1addc238c2182de30f01da1b70fef9`
BLAKE2b-256	`f45755002e96433324c56619da1e8343e74f8cba9697dad8bc38ff6e82a2a4fc`

Algorithm	Hash digest
SHA256	`94286db62f11356eadf756144ffb9c21f608026cdad477b65c8ade77f9fd2d56`
MD5	`a341f4a216ae71fafb02edea573ab82c`
BLAKE2b-256	`f3e1f1a9a0f269e986551b255c3baff0095253d4c86d7d5390433f0f0e1ec1cc`

Algorithm	Hash digest
SHA256	`80a0232033261c95b678eb0de972d3b6b57eca29427c33a6e8b7fcc3423b4fd3`
MD5	`f8dd3aadf1a9a936ef1038e77898ae66`
BLAKE2b-256	`928f4da31461a056bffd0e2352bcdc7e24a5b03fbf9e6b793f0affafeddd88d2`

Algorithm	Hash digest
SHA256	`a8bc56e6d35a05825f8839630e75f75b1f28c98cb41d7cd8b63f8a5c824d32c0`
MD5	`aea608640b078fe58403828bd22a05d2`
BLAKE2b-256	`410e4a361553653c6a7c2161be91a0033a02e406d93eac630b057c8eb56f57af`

Algorithm	Hash digest
SHA256	`10ab4ef44e5bdb029b25775ea6af89719f2b75d28f905cd2f909450e80c23cab`
MD5	`b67fb2cde7b548650525c2ebfbe6b769`
BLAKE2b-256	`7ee33e51af8d6004e6d309aef406135f5a2b869fd344d16f50c9116d5ecd0b39`

Algorithm	Hash digest
SHA256	`53dd089ad938e7de65fdfe5476498fab88d5c1c5e63c2cb52de7c92cad363062`
MD5	`271e7954457bfdd68ef1033b0569751d`
BLAKE2b-256	`1a1ba986ebcf4131b68ff9369a88e30f1928f246ef7ca79b09d8c818c3d91a9d`

bitbully 0.0.78

Navigation

Verified details

Project links

GitHub Statistics

Maintainers

Unverified details

Meta

Classifiers

Project description

BitBully: A fast and perfect-playing Connect-4 Agent for Python 3 & C/C++

Quickstart

Installation

Usage

Table of Contents

Features

Who is this for?

Installation

Prerequisites

Build and Install

From PyPI (Recommended)

Python API Docs

Usage

🚀 BitBully: Getting Started with a Jupyter Notebook

🎮 Play a Game of Connect-4 with a simple Jupyter Notebook Widget

High-level Python API (recommended)

Empty board + play moves incrementally

Initialize directly from a move sequence

Create positions (moves, strings, arrays) and round-trip them

Legal moves and remaining moves

Some board utilities

Solver Quickstart: evaluate a position and pick a move

Play a small game loop (agent vs. itself)

Tie-breaking strategies for best_move

Different Search Algorithms

Low-level C++ bindings (advanced)

BoardCore Examples

Create and Print a Board

Play Moves and Check for Winning Positions

Set a Board from a Move List or Array

Generate Random Boards

Mirroring Boards and Symmetry

Hashing, Equality, and Copies

BitBullyCore: Connect-4 Solver Examples

Solve a Position with MTD(f)

Score All Moves in a Position

Using the Solver in a Loop (Move Selection)

Further Examples using the BitBully Solver

Further Usage Examples for BitBully Core

Opening Book Examples

Load an Opening Book

Accessing Entries

Evaluating a Board Position

Check Whether a Position Is in the Opening Book

Benchmarking

Setup

Aggregation & Reported Metrics

Statistical Significance & p-Value Interpretation

Notes & Caveats

Machine Setup

Results (BitBully vs Baseline)

Interpretation of the Benchmarking Results

Advanced Build and Install

Prerequisites

From Source

Building Static Library with CMake

Contributing & Development

License

Contact

Further Ressources

Acknowledgments

Project details

Verified details

Project links

GitHub Statistics

Maintainers

Unverified details

Meta

Classifiers

Release history Release notifications | RSS feed

Tie-breaking strategies for `best_move`

Algorithm	Hash digest
SHA256	`ca12e7a692299f93837feb68b8b16a140478bc89bb05ccc24292c7be5a74ae3d`
MD5	`dfa143e595155facaac0324af3be48aa`
BLAKE2b-256	`2cbb6431079354c8cf1f5319b3bf2501e388dd29392f9037f8c94db781247762`

Algorithm	Hash digest
SHA256	`152249a39509c5cdecb9de826a1979518622eca251dfe8f93f25b0c638d68642`
MD5	`ec98097fe615c213a6c1c424cda13e68`
BLAKE2b-256	`b954154db7d794cfadb86e35a8a4ce47b2d5abac45f13a2537ab2101c3d95b64`

Algorithm	Hash digest
SHA256	`7473374c73b5ab81c42afd4d330674804c12b84d6282785b66b7d7da19e9bad3`
MD5	`ca6359c432b358a77b2c9d5ddb718b26`
BLAKE2b-256	`93b4b61b0583a46e535efa633132ae87bfb7fab4ce8a5a1c467dbeff5b6d15f2`

Algorithm	Hash digest
SHA256	`cd5fb371eb23ae31f0ee9bc0af7d70a868664e923d7340a1ca81827995f27682`
MD5	`ff2b76bb3474e17c8379b5a86b15a119`
BLAKE2b-256	`e9182093282f72e20836682d2d7d5f6892ab98042bb7ca97b5602e64db961e23`

Algorithm	Hash digest
SHA256	`3e662c32a6f612339d4cb446874efef08a226ecbd0d663f075b85f1d2eef1c5f`
MD5	`706a18a9ab74c20e737e7cba7fe140de`
BLAKE2b-256	`0ca1e538278d1672f5f889a2c7f039c7e0f99a84560bde8ab594e7756348abf9`

Algorithm	Hash digest
SHA256	`3a7f79ab164379755af7e143a09e0bd63e664ebd24d41b3916e9968e3a9da6b5`
MD5	`03d1eb68e10386cef8c263c64f5f4471`
BLAKE2b-256	`9933fd994d0b60f44e1aa08c4677bb8fef4bd7d863c06e8da1cfa2b1e0b0e529`