New J.A Compiles

[Jim Ablett]

https://github.com/Quanticade/Quanticade
Quanticade 0.8 dev.fd359fb by DarkNeutrino

Quanticade 0.8 dev.fd359fb 64 JA

Windows/Linux & Android profiled builds

https://drive.proton.me/urls/GV05GYQ66R#XZHi38Xbt2RQ

Jim.

Update:

Quanticade 0.9 Electra 64 JA

Windows/Linux & Android clang profiled builds

https://drive.proton.me/urls/FP4A4SP5G0#7RHD7eCvZOHX

Jim.

Update:

Quanticade Chimera 1.1 64 JA

Windows/Linux & Android profiled builds

https://drive.proton.me/urls/FRFTVK9CSG#7J5hLJ8zNZQ9

Jim.

I don't know if it's a compiler or source code bug, but both under WIN 10 and WIN 11 the engine crashes with more than one thread, even in command mode e.g. with “setoption name Threads value 2”.

What happens when you type 'Threads' in lowercase 'threads'

Jim.

[Dokterchen]

https://github.com/Quanticade/Quanticade
Quanticade 0.8 dev.fd359fb by DarkNeutrino

Quanticade 0.8 dev.fd359fb 64 JA

Windows/Linux & Android profiled builds

https://drive.proton.me/urls/GV05GYQ66R#XZHi38Xbt2RQ

Jim.

Update:

Quanticade 0.9 Electra 64 JA

Windows/Linux & Android clang profiled builds

https://drive.proton.me/urls/FP4A4SP5G0#7RHD7eCvZOHX

Jim.

Update:

Quanticade Chimera 1.1 64 JA

Windows/Linux & Android profiled builds

https://drive.proton.me/urls/FRFTVK9CSG#7J5hLJ8zNZQ9

Jim.

I don't know if it's a compiler or source code bug, but both under WIN 10 and WIN 11 the engine crashes with more than one thread, even in command mode e.g. with “setoption name Threads value 2”.

What happens when you type 'Threads' in lowercase 'threads'

Jim.

Hi Jim,

Then Quanticade ignores the statement and runs with one thread. This is also under Arena. With the UCI settings thread = 1 Quanticade works but with thread = 2 (or higher) Quanticade crashes.

[Dokterchen]

https://github.com/Quanticade/Quanticade
Quanticade 0.8 dev.fd359fb by DarkNeutrino

Quanticade 0.8 dev.fd359fb 64 JA

Windows/Linux & Android profiled builds

https://drive.proton.me/urls/GV05GYQ66R#XZHi38Xbt2RQ

Jim.

Update:

Quanticade 0.9 Electra 64 JA

Windows/Linux & Android clang profiled builds

https://drive.proton.me/urls/FP4A4SP5G0#7RHD7eCvZOHX

Jim.

Update:

Quanticade Chimera 1.1 64 JA

Windows/Linux & Android profiled builds

https://drive.proton.me/urls/FRFTVK9CSG#7J5hLJ8zNZQ9

Jim.

I don't know if it's a compiler or source code bug, but both under WIN 10 and WIN 11 the engine crashes with more than one thread, even in command mode e.g. with “setoption name Threads value 2”.

What happens when you type 'Threads' in lowercase 'threads'

Jim.

Hi Jim,

Then Quanticade ignores the statement and runs with one thread. This is also under Arena. With the UCI settings thread = 1 Quanticade works but with thread = 2 (or higher) Quanticade crashes.

In the meantime I have seen that the author has already released a bugfix version 1.2 - problem solved

[Jim Ablett]

https://stockfishchess.org/

Stockfish 16 Classical 64 JA

Last version of Stockfish with classical evaluation option.
NNUE set to off by default (can be enabled in uci options)

Windows/Linux & Android profiled builds

Proton link:
https://drive.proton.me/urls/5ST0P4NXCW#9XaomOjGdm5L

Smash Link:
https://fromsmash.com/Stockfish-16-Classical

Jim.

[supersharp77]

Hey Jim See You've Been Busy Indeed!! Thanks!!.... I've Got Quite A few Unknown Engines Perhaps You Can Assist On....Thanks I Advance....Incoming!!!

https://github.com/healeycodes/andoma/releases

"

My blog post: Building My Own Chess Engine


A chess engine which implements:

Alpha-beta pruning for move searching
Move ordering based off heuristics like captures and promotions
Tomasz Michniewski's Simplified Evaluation Function for board evaluation and piece-square tables
A slice of the Universal Chess Interface (UCI) to allow challenges via lichess.org
A command-line user interface

It uses Python 3.8 with Mypy type hints and unit + integration tests.

See Contributing to help out!

Install

pip install -r requirements.txt

[supersharp77]

Thanks In Advance Jim A.!! AR

GoFish Chess Engine https://github.com/A7mad-2000as/GoFish/ ... hessEngine

"GoFish is an open-source chess engine project written in Golang. The project aims to assist developers who are looking to implement chess engines by providing a ready-to-use framework that includes common engine modules, such as board representation, move encoding, and UCI compatability. This allows developers to plug in custom search and evaluation modules, which constitutes the algorithmic and heuristic parts of a chess engine. GoFish also includes a default search and evaluation implementation which can be used to construct a working engine if required.

If you use this work, please cite this paper.
Basic Workflow

GoFish defines a contract for implementing custom search and evaluation modules. The contract is represented by Golang interfaces which requires implementation. If all functions defined in either interface are implemented by a Golang type, then that type can be used as a custom implementation which may be passed into the engine framwork to construct a working engine. Engine Development Workflow
Usage

GoFish employs Golang as the language of choice. Hence, Golang developement and runtime tools should be installed from the official download page. The installer will guide you through the necessary steps. Make sure to allow the installer to add Golang to PATH to allow using command line tools easily.

A driver Golang module should be initialized locally in your required directory using the command go mod init <module name> which should create a go.mod and go.sum files in the workspace. The driver should introduce a Golang executable main package which imports GoFish and invokes either NewDefaultEngineInterface() which uses a default search and evaluation implementations, or NewCustomEngineInterface(searcher, evaluator) which requires custom implementations. Both the functions return an EngineInterface object which has a StartEngine() method used to initiate the engine.

NOTE: Depending on the version of Golang installed, you may need to run go get github.com/A7mad-2000as/GoFish/chessEngine after initializing the local Golang module and before using the imported GoFish module to be able to use it without errors.

A working driver which uses the default implementation would look like this:

package main

import (
"github.com/A7mad-2000as/GoFish/chessEngine"
)

func main() {
engineInterface := chessEngine.NewDefaultEngineInterface()
engineInterface.StartEngine()
}

A custom implementation can be defined by implementing the GameSearcher and Evaluator interfaces defined in chessEngine/interfaces.go. The functions and their descriptions are given in the following two tables
GameSearcher Interface
Function Description Returns
Reset() Reset the game searcher to the initial state. Called when uci command is received -
ResetToNewGame() Setup the game searcher state so that a new chess game is now being searched. Called when ucinewgame command is received -
GetOptions() Get the UCI options offered by the searcher. Useful for option and setoption UCI commands A map keyed by the option name, with EngineOption values as defined in the chessEngine/interfaces.go file
Position() Returns the current position state The current Position object depending on the search progress
RecordPositionHash(positionHash) Add the given position hash to the history of encountered positions, useful for three-fold repetition detection -
IniitalizeSearchInfo(fenString, evaluator) Setup the game searcher state to consider the position described by the given FEN string. Called after position UCI command is received -
InitializeTimeManager(remainingTime, increment, moveTime, movesToGo, depth, nodeCount) Initialize the time manager by the timing information given using the parameters of the go UCI comand. The time value -1 indicates infinite time -
StartSearch() Begin a new Search based on the game searcher internal state. Called after go UCI command is received and after setting up internal state (i.e., position and time manager info). Ends after polling of the stop flag indicates that the search should end The best move found by the search
StopSearch() Stop an ongoing search by setting a stop flag and returning. Called after stop UCI command is received -
CleanUp() Clean up any resources used be the engine before terminating completely. Called after quit UCI command is received -
Evaluator Interface
Function Description Returns
EvaluatePosition(position) Get the static evaluation result of the given position The centipawn static evaluation score
GetMiddleGamePieceSquareTable() Get the middlegame piece square table scores. Used by the Position object to update scores incrementally after doing and undoing moves Middlegame piece square table
GetEndGamePieceSquareTable() Get the endgame piece square table scores. Used by the Position object to update scores incrementally after doing and undoing moves Endgame piece square table
GetMiddleGamePieceValues() Get the piece material value during the middlegame phase. Used by the Position object to update scores incrementally after doing and undoing moves Middlegame piece values in the following order: Pawn, Knight, Bishop, Rook, Queen, King
GetEndGamePieceValues() Get the piece material value during the endgame phase. Used by the Position object to update scores incrementally after doing and undoing moves Endgame piece values in the following order: Pawn, Knight, Bishop, Rook, Queen, King
GetPhaseValues() Get the phase weight of each piece type. Used for determination of the current phase of the game. Higher value biases the game towards middlegame rather than endgame Phase values for each piece type in the following order: Pawn, Knight, Bishop, Rook, Queen, King
GetTotalPhaseWeight() Get The total phase score by summing up the phase values of each piece type scaled by the number of pieces. Mostly, each piece value should be scaled by the number of pieces in the starting position for both colors combined. For example, the pawn weight should be scaled by 16 The total phase score

An executable can be obtained by running go build inside the driver module directory. As most engines, GoFish does not have its own GUI and rather implements the UCI protocol which allows integration with many GUIs which implement the same protocol. Some of the most popular GUIs are: Arena, and CuteChess. Instructions on how to load an engine executable is avaiable on the respective GUI page."

[supersharp77]

Thanks In Advance Jim A.!! AR

Oracle Engine Project https://github.com/Athroniaeth/oracle

"Oracle Chess Engine
Introduction

Oracle is the first chess engine that plays like a human, from amateur to super GM. She can play like a 2800-rated player in classical or an 800-rated player in blitz, or at any other level, in any time control.
Features

Human-like Play: Oracle adapts her predictions to any rating level from amateur to super GM.
Time Control Flexibility: Oracle adapts her predictions to 4 different time controls: bullet, blitz, rapid, or classical.
Expected Score Evaluations: Instead of using centipawns, Oracle evaluates positions by giving White's expected score out of 100 games. This expected score takes into account the position, the likeliest next moves, the rating of both players and the time control.
Two Modes:
Oracle_one_move: Takes a PGN game as input and predicts the likeliest next moves.
Oracle_pgn_file: Takes a PGN file with multiple games and predicts every move of every game, useful for creating data to test Oracle.

Usage

Oracle_one_move: Set your openAI API key and the path to your Stockfish at the top of the file then run the file. Past the PGN up to the move you want to predict into the console, type END and press Enter
Oracle_pgn_file: Set your openAI API key, the path to your Stockfish, your input pgn file, and your output csv file, and then run the file. Oracle will write her predictions for every move of every game of the PGN into the csv file.

Examples

Ding vs. Nepo, round 14 after 58...a3

Position after 58...a3 in the last tie-break of the 2023 World Championship. Stockfish shows 0.00, but considering it's rapid, Oracle only gives white a 18.50% expected score. Nepo ended up blundering with 59. Qc7??, which was the likeliest move according to Oracle.

Ding vs. Nepo, Input and Ouput

Dubov vs. Nepo, position after 11... Nc6

Position after 11...Nc6 in the infamous "Danse of the Knights" pre-arranged draw between Daniil Dubov and Ian Nepomniachtchi at the 2023 World Blitz Championship. Despite it being an obviously bad move, Oracle predicts 12. Nb1 that was actually played by Nepo and gives it a high 72% likelihood.

Dubov vs. Nepo - Input and Ouput
Requirements

Oracle uses GPT-3.5 turbo instruct and Stockfish to deliver human-like chess moves. Users need an OpenAI API key and a version of Stockfish, which can be downloaded here.
Configuration

By default, Stockfish is set to a time limit of 1.3 seconds, a depth limit of 20 plies, uses 8 threads and 512 MB of hash. You can change these settings in the analyze_moves function.
Time

On my computer, Oracle takes on average about 2 seconds per move. This duration could be reduced with an optimized code and better hardware.
Cost

Because Oracle uses GPT for her prediction, she is costly! The average cost is ~400 predictions per $1 but can vary greatly with the length of the prompt (up to 10.000 predictions per $1 for opening moves with a short header)
Author's Note

I am a FIDE Master and Woman International Master with no previous coding experience, so the code might contains mistakes or improper formulations.
Oracle's name"

[supersharp77]

Thanks In Adance Jim A.!!!! AR



Mu Zero https://github.com/johan-gras/MuZero

"MuZero

This repository is a Python implementation of the MuZero algorithm. It is based upon the pre-print paper and the pseudocode describing the Muzero framework. Neural computations are implemented with Tensorflow.

You can easily train your own MuZero, more specifically for one player and non-image based environments (such as CartPole). If you wish to train Muzero on other kinds of environments, this codebase can be used with slight modifications.

DISCLAIMER: this code is early research code. What this means is:

Silent bugs may exist.
It may not work reliably on other environments or with other hyper-parameters.
The code quality and documentation are quite lacking, and much of the code might still feel "in-progress".
The training and testing pipeline is not very advanced.

Dependencies

We run this code using:

Conda 4.7.12
Python 3.7
Tensorflow 2.0.0
Numpy 1.17.3

Training your MuZero

This code must be run from the main function in muzero.py (don't forget to first configure your conda environment).
Training a Cartpole-v1 bot

To train a model, please follow these steps:

Create or modify an existing configuration of Muzero in config.py.
Call the right configuration inside the main of muzero.py.
Run the main function: python muzero.py.

Training on an other environment

To train on a different environment than Cartpole-v1, please follow these additional steps:

1) Create a class that extends AbstractGame, this class should implement the behavior of your environment. For instance, the CartPole class extends AbstractGame and works as a wrapper upon gym CartPole-v1. You can use the CartPole class as a template for any gym environment.

2) This step is optional (only if you want to use a different kind of network architecture or value/reward transform). Create a class that extends BaseNetwork, this class should implement the different networks (representation, value, policy, reward and dynamic) and value/reward transforms. For instance, the CartPoleNetwork class extends BaseNetwork and implements fully connected networks.

3) This step is optional (only if you use a different value/reward transform). You should implement the corresponding inverse value/reward transform by modifying the loss_value and loss_reward function inside training.py.
Differences from the paper

This implementation differ from the original paper in the following manners:

We use fully connected layers instead of convolutional ones. This is due to the nature of our environment (Cartpole-v1) which as no spatial correlation in the observation vector.
We don't scale the hidden state between 0 and 1 using min-max normalization. Instead we use a tanh function that maps any values in a range between -1 and 1.
We do use a slightly simple invertible transform for the value prediction by removing the linear term.
During training, samples are drawn from a uniform distribution instead of using prioritized replay.
We also scale the loss of each head by 1/K (with K the number of unrolled steps). But, instead we consider that K is always constant (even if it is not always true).


Mu Zero https://github.com/akarshkumar0101/mu-zero/tree/main

"My implementation of the mu-zero algorithm from DeepMind for chess. "

Mu Zero https://github.com/wkudsk/MuZero

"MuZero
Work done for MuZero Chess Ai work. Currently working on a chess game that the muzero can play, once I have finished working on the game such a way that humans can play it, I will add support for computer play, and then finish by constructing the MuZero AI."

https://github.com/gabriel-combe/MuZeroChess

[supersharp77]

A personal Favorite Of Mine With The Most Interesting And Aggressive Playing Style!!!! A JA Compile (CPU/Open CL) Would be Excellent to Test vs The Original Thx In Advance Jim A.!! AR

https://github.com/LeelaChessZero/lc0/releases?page=9

Source https://github.com/LeelaChessZero/lc0/a ... 0.16.0.zip

"Lc0

Lc0 is a UCI-compliant chess engine designed to play chess via neural network, specifically those of the LeelaChessZero project.
Downloading source

Lc0 can be acquired either via a git clone or an archive download from GitHub. Be aware that there is a required submodule which isn't included in source archives.

For essentially all purposes, including selfplay game generation and match play, we highly recommend using the latest release/version branch (for example release/0.31), which is equivalent to using the latest version tag.

Versioning follows the Semantic Versioning guidelines, with major, minor and patch sections. The training server enforces game quality using the versions output by the client and engine.

Download using git:

git clone -b release/0.31 --recurse-submodules https://github.com/LeelaChessZero/lc0.git

If you have cloned already an old version, fetch, view and checkout a new branch:

git fetch --all
git branch --all
git checkout -t remotes/origin/release/0.31

If you prefer to download an archive, you need to also download and place the submodule:

Download the .zip file (.tar.gz archive is also available)
Extract
Download https://github.com/LeelaChessZero/lczer ... master.zip (also available as .tar.gz)
Move the second archive into the first archive's libs/lczero-common/ folder and extract
The final form should look like <TOP>/libs/lczero-common/proto/

Having successfully acquired Lc0 via either of these methods, proceed to the build section below and follow the instructions for your OS.
Building and running Lc0

Building should be easier now than it was in the past. Please report any problems you have.

Aside from the git submodule, lc0 requires the Meson build system and at least one backend library for evaluating the neural network, as well as the required zlib. (gtest is optionally used for the test suite.) If your system already has this library installed, they will be used; otherwise Meson will generate its own copy of the two (a "subproject"), which in turn requires that git is installed (yes, separately from cloning the actual lc0 repository). Meson also requires python and Ninja.

Backend support includes (in theory) any CBLAS-compatible library for CPU usage, such as OpenBLAS or Intel's DNNL or MKL. For GPUs, OpenCL and CUDA+cudnn are supported, while DX-12 can be used in Windows 10 with latest drivers.

Finally, lc0 requires a compiler supporting C++17. Minimal versions seem to be g++ v8.0, clang v5.0 (with C++17 stdlib) or Visual Studio 2017.

Note that cuda checks the compiler version and stops even with newer compilers, and to work around this we have added the nvcc_ccbin build option. This is more of an issue with new Linux versions, but you can get around it by using an earlier version of gcc just for cuda. As an example, adding -Dnvcc_ccbin=g++-9 to the build.sh command line will use g++-9 with cuda instead of the system compiler.

Given those basics, the OS and backend specific instructions are below.
Linux
Generic

Install backend:
If you want to use NVidia graphics cards Install CUDA and cuDNN.
If you want to use AMD graphics cards install OpenCL.
if you want OpenBLAS version Install OpenBLAS (libopenblas-dev).
Install ninja build (ninja-build), meson, and (optionally) gtest (libgtest-dev).
Go to lc0/
Run ./build.sh
lc0 will be in lc0/build/release/ directory
Unzip a neural network in the same directory as the binary.

If you want to build with a different compiler, pass the CC and CXX environment variables:

CC=clang-6.0 CXX=clang++-6.0 ./build.sh

Note on installing CUDA on Ubuntu

Nvidia provides .deb packages. CUDA will be installed in /usr/local/cuda-10.0 and requires 3GB of diskspace. If your /usr/local partition doesn't have that much space left you can create a symbolic link before doing the install; for example: sudo ln -s /opt/cuda-10.0 /usr/local/cuda-10.0

The instructions given on the nvidia website tell you to finish with apt install cuda. However, this might not work (missing dependencies). In that case use apt install cuda-10-0. Afterwards you can install the meta package cuda which will cause an automatic upgrade to a newer version when that comes available (assuming you use Installer Type deb (network), if you'd want that (just cuda-10-0 will stay at version 10). If you don't know what to do, only install cuda-10-0.

cuDNN exists of two packages, the Runtime Library and the Developer Library (both a .deb package).

Before you can download the latter you need to create a (free) "developer" account with nvidia for which at least a legit email address is required (their website says: The e-mail address is not made public and will only be used if you wish to receive a new password or wish to receive certain news or notifications by e-mail.). Further they ask for a name, date of birth (not visible later on), country, organisation ("LeelaZero" if you have none), primary industry segment ("Other"/none) and which development areas you are interested in ("Deep Learning").
Ubuntu 18.04

For Ubuntu 18.04 you need the latest version of meson, libstdc++-8-dev, and clang-6.0 before performing the steps above:

sudo apt-get install libstdc++-8-dev clang-6.0 ninja-build pkg-config
pip3 install meson --user
CC=clang-6.0 CXX=clang++-6.0 INSTALL_PREFIX=~/.local ./build.sh

Make sure that ~/.local/bin is in your PATH environment variable. You can now type lc0 --help and start.
Ubuntu 16.04

For Ubuntu 16.04 you need the latest version of meson, ninja, clang-6.0, and libstdc++-8:

wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
sudo apt-add-repository 'deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-6.0 main'
sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt-get update
sudo apt-get install clang-6.0 libstdc++-8-dev
pip3 install meson ninja --user
CC=clang-6.0 CXX=clang++-6.0 INSTALL_PREFIX=~/.local ./build.sh

Make sure that ~/.local/bin is in your PATH environment variable. You can now type lc0 --help and start.
openSUSE (all versions)

Instructions, packages and tools for building on openSUSE are at openSUSE_install.md
Docker

Use https://github.com/vochicong/lc0-docker to run latest releases of lc0 and the client inside a Docker container.
Windows

Here are the brief instructions for CUDA/CuDNN, for details and other options see windows-build.md.

Install Microsoft Visual Studio (2017 or later)
Install CUDA
Install cuDNN.
Install Python3
Install Meson: pip3 install --upgrade meson
Edit build.cmd:

Set CUDA_PATH with your CUDA directory
Set CUDNN_PATH with your cuDNN directory (may be the same with CUDA_PATH)

Run build.cmd. It will ask permission to delete the build directory, then generate MSVS project and pause.

Then either:

Hit Enter to build it.
Resulting binary will be build/lc0.exe

Or.

Open generated solution build/lc0.sln in Visual Studio and build yourself.

Mac

First you need to install some required packages through Terminal:

Install brew as per the instructions at https://brew.sh/
Install python3: brew install python3
Install meson: brew install meson
Install ninja: brew install ninja
(For Mac OS 10.14 Mojave, or if the other step 5 fails):

Install developer tools: xcode-select --install
When using Mojave install SDK headers: installer -pkg /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg -target / (if this doesn't work, use sudo installer instead of just installer.)

Or.

(For MacOS 10.15 Catalina, or if the other step 5 fails):

Install Xcode command-line tools: xcode-select --install
Install "XCode Developer Tools" through the app store. (First one on the list of Apps if searched.)
Associate the SDK headers in XCode with a command: export CPATH=`xcrun --show-sdk-path`/usr/include

Now download the lc0 source, if you haven't already done so, following the instructions earlier in the page.

Go to the lc0 directory.
Run ./build.sh -Dgtest=false (needs step 5)

Raspberry Pi

You'll need to be running the latest Raspberry Pi OS "buster".

Install OpenBLAS

git clone https://github.com/xianyi/OpenBLAS.git
cd OpenBLAS/
make
sudo make PREFIX=/usr install
cd ..

Install Meson

pip install meson
pip install ninja

Install compiler and standard libraries

sudo apt install clang-6.0 libstdc++-8-dev

Clone lc0 and compile

git clone https://github.com/LeelaChessZero/lc0.git
cd lc0
git submodule update --init --recursive
CC=clang-6.0 CXX=clang++-6.0 ./build.sh -Ddefault_library=static

The resulting binary will be in build/release

Python bindings

Python bindings can be built and installed as follows.

pip install --user git+https://github.com/LeelaChessZero/lc0.git

This will build the package lczero-bindings and install it to your Python user install directory. All the lc0 functionality related to position evaluation is now available in the module lczero.backends. An example interactive session can be found here.
License

Leela Chess is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Leela Chess is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with Leela Chess. If not, see http://www.gnu.org/licenses/.
Additional permission under GNU GPL version 3 section 7

The source files of Lc0 with the exception of the BLAS and OpenCL backends (all files in the blas and opencl sub-directories) have the following additional permission, as allowed under GNU GPL version 3 section 7:

If you modify this Program, or any covered work, by linking or combining it with NVIDIA Corporation's libraries from the NVIDIA CUDA Toolkit and the NVIDIA CUDA Deep Neural Network library (or a modified version of those libraries), containing parts covered by the terms of the respective license agreement, the licensors of this Program grant you additional permission to convey the resulting

[supersharp77]

Crafty 25.3-25.8......Series Lastly Help Jim A. We Could All Use A Jim A Compile For The Legendary Crafty Chess Engine (Hopefully One A Bit Deeper And Stronger!!!! ) Windows

https://github.com/MichaelB7/Crafty

Source 25.3 https://github.com/MichaelB7/Crafty/arc ... s/25-3.zip

Source 25.2 https://github.com/MichaelB7/Crafty/arc ... s/25.2.zip

And Finally We Could All Use A Android Crafty Version (Any) That works as A Pure UCI add on Android Devices (Only Chess For Android GUI ca use Winboard Crafty Android Compiles) The Only one I see is A Crafty23.5UCI-JA which does load on occasion in windows but was never compiled for Android As Far As I remember....

"Crafty 23.5 JA UCI is a free, open-source chess engine interface that uses the Universal Chess Interface (UCI) protocol. The UCI protocol allows chess engines to communicate with chess GUIs using text commands."

https://github.com/lazydroid/crafty-chess


ps I did Just See A Crafty 25.6 JA compile but I'm not sure That Was You...If So Thanks JA!!

https://workupload.com/start/LCdveDk3Jdh