i13e / osmanthus

♟️ An algorithmic chess engine, written in Python.

Hello There! I'm Ian

I'm a software developer with 3 years of industry experience. I'm passionate about writing high-quality, maintainable code and learning new technologies. Outside of programming, I enjoy exploring scenic trails in Prospect Park, playing speed chess, listening to Nurture by Porter Robinson, and cooking authentic Italian food.

Skills

• Languages: Python, TypeScript/JavaScript, Bash, Nix, Rust
• Frameworks/Libraries: React, Node.js, NumPy, Pandas, Matplotlib
• Databases: PostgreSQL, MySQL, MongoDB
• Tools: Linux, Git, Docker, GCP, AWS, Azure, GitHub Actions

Projects

Here are some of my top projects:

• Osmanthus: An algorithmic chess engine, written in Python.
• Euler: An all-in-one Python tool for solving Project Euler challenges.
• Robinson: Extract data from the Spotify API and store it in a database.

Mini-Projects

• hostupd: Update /etc/hosts and append a custom blocklist, written in POSIX sh.
• timeshift-autosnap-wrapper: Take only one snapshot per system update.
• cfg: Config files for my Linux workspace, managed using git --bare.

I'm currently working on learning on learning about and configuring NixOS.

Get in Touch

• Website: https://i13e.org
• Email: [email protected]

Feel free to reach out if you'd like to collaborate on a project or just want to connect!

osmanthus's Issues

Implement Robust CI/CD Pipelines using Tox

Benefits:

Improved code quality and reliability through automated testing.
Faster feedback loops for pull requests and changes.
Simplified setup for contributors and users.
Consistent testing and linting across different Python versions.

Links:

1. Tox GitHub repository: https://github.com/tox-dev/tox
2. Example of Tox integration in workflows: https://github.com/asottile/workflows/tree/main/.github/workflows
3. Tutorial on setting up Tox for CI/CD: https://www.youtube.com/watch?v=KKJL8bM4cis
4. CI/CD using Tox demonstration: https://www.youtube.com/watch?v=75WBE_qbpGk&pp=ygURdG94IGFudGhvbnkgY29kd2E%3D

Publish Package to PyPI with GitHub Actions CI/CD

This issue proposes the implementation of a streamlined process for packaging the project and publishing it to PyPI using GitHub Actions CI/CD workflows. By automating the packaging and distribution process, we can simplify and expedite the deployment of the project to PyPI, making it more accessible to the Python community.

Relevant Links:

1. Packaging and Publishing with GitHub Actions CI/CD Workflows: https://packaging.python.org/en/latest/guides/publishing-package-distribution-releases-using-github-actions-ci-cd-workflows/
2. GitHub Actions for Building and Testing Python Projects: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
3. Example Python Publish Workflow: https://github.com/i13e/osmanthus/new/master?filename=.github%2Fworkflows%2Fpython-publish.yml&workflow_template=ci%2Fpython-publish

Add UCI support

Currently, Osmanthus lacks support for the Universal Chess Interface (UCI) protocol. This protocol is widely used in the chess community to facilitate communication between chess engines and user interfaces, making it easier for users to interact with the engine.

Therefore, I propose to add UCI support to Osmanthus. This will enable the engine to be used with a wider range of user interfaces, such as ChessBase, Arena, Lichess, and SCID. Additionally, it will make it easier for developers to integrate Osmanthus into their chess software.

I plan to implement the UCI protocol according to the official specification and will test it thoroughly to ensure that it works correctly with different user interfaces. I will also provide documentation and examples to help users and developers get started with the engine and the UCI protocol.

Add support for the threefold repetition rule using incremental transposition tables

Currently, Osmanthus does not support the threefold repetition rule, which states that a player can claim a draw if the same position occurs three times with the same player to move. While Python's chess library has support for this rule (see here), it is slow because it does not use incremental transposition tables.

To improve the performance of the engine, we should add support for the threefold repetition rule using incremental transposition tables. This would allow us to quickly check whether a position has occurred three times in the game and avoid recomputing the same position repeatedly.

Specifically, we should implement the following changes:

1. Add a new transposition table for storing positions and their repetition counts.
2. Update the move generator to check whether a move would result in a repeated position.
3. Increment the repetition count in the transposition table whenever a position occurs for the second time.
4. If a position occurs for the third time, the player can claim a draw.

By implementing these changes, we can ensure that Osmanthus correctly handles the threefold repetition rule while maintaining good performance.