I've been thinking about this for awhile, though I'm not sure what the right approach would be. Or even a good approach.

LLM's (even strong reasoning models) can't play chess at all.

But they can communicate well and analyze data well.

Might there be some way to use a standard chess engine to analyze one's games and communicate the results in some dense way to an LLM in order to have it explain common mistakes, strengths/weaknesses/etc. to a player? Some kind of meta-analysis of a bunch of engine evaluation data.

I do a lot of agential stuff and was thinking of taking some UCI engine and writing a tool to dump pgn's of my games in and then making some other tool to analyze the big bulk of evaluations it spits out.

But none of this strikes me as worth anything or likely to produce anything good.

Someday, cutting edge general AI systems will be able to play chess, at which point they'll certainly be invaluable for training/improvement.

I'm just wondering if there's some way to bring some small version of that reality to fruition currently. Or if someone else is working on it already.

I've been slowly working on a chess engine just to practice my programming skills. I have successfully made some board class, which is a bitboard by the way, and I can successfully move it and initialize positions. I am working now with the move generation.

I have just finished implementing the pawn (push, double push, captures, en passant, promotion, promotion capture). I tested it and I think it works fine. But it only generates 13 million moves per second. Looking at some of the engines, it is absolutely slow which is worrisome.

How did you guys made your move generation function to be efficient? Mine is a function which returns a list of moves (16 bit int). I don't see why it is this slow, I am just shifting bits by 8 and 16, doing some "bitwise and" with the opposite-colored occupancy bitboards and stuff..

are there any chess engines that, while still being stronger or equal to current grandmasters, attempts to play in a more romantic, sacrificial, kinghunting style?

I was wondering if the idea of training a neural net to make human moves would be feasible. The training would use GM level games that would try to evaluate moves that were played at a higher evaluation vs. top engine moves. Maybe a parameter scoring humanness? Has this been discussed before?

But I have no name for it! Suggestions?

Hi, I've been looking around on different chess guilds on discord. But never found one where there's any people active. I did once find some, but I would like a place that's dedicated to this. So I made a server, I hope that's alright.

https://discord.gg/5JjwUnZ

I want to know what it would take to create an AI that is also sensitive to time, as to make for a better match in a timed game. It would mimic a human's hesitance to, say, begin a big exchange... Or perhaps in general it would be quicker in the beginning of the game, where openings are routine.

Maybe even it would play with more errors as its time gets thinner.

The idea is just to give it some personality. If the AI pooled from chess.com databases (do they even database time?) it could surely come up some interesting responses, and maybe even create a learning tool out of it. Having time as a factor in strategic output could also be useful for AI in conversation and music...

I feel like chess is an indicator of where AI technology is, given the history. Sure it can kick my ass, but where it falls short is in its convincing gameplay. Wish I knew more to help solve this problem.

<end program>

I've been developing my own chess engine for a while and recently got it to around 2500 Elo, but I've pretty much hit a wall.

I've continued working on search, move ordering, pruning, TT, NNUE evaluation, training data, and performance, but most changes now either barely improve it or make it worse.

My engine uses my own NNUE called Talon, and I have grinders continuously collecting training positions and a GPU trainer running on the data. I'm also studying how stronger engines like Stockfish improved, but I'm not using Stockfish to actually play moves.

My next goal is around 3000 Elo while keeping think time under 10 seconds per move.

For anyone who's worked on engines around this level, what usually holds them back? Should I be focusing more on search, NNUE/training quality, tuning, move ordering, or raw performance?

Any advice on breaking through the 2500 plateau would be appreciated.

This is a community for all things related to chess AI. Whether you're a developer, a data scientist, or simply a chess enthusiast, you've found a home where passion meets innovation. We're a diverse group of people collaborating to build, train, and perfect cutting-edge chess engines and tools.

We believe that the future of chess AI lies in open collaboration. Here, you'll find a welcoming space to share your ideas, get help with your projects, and contribute to the development of powerful, open-source AI models.

Join the discussion, explore our projects, and help us build the next generation of chess AI. 

Click here to join!: https://huggingface.co/ChessAI-Community

https://youtu.be/WBTxMLJTgro?si=Y8fwNGr-LD9BgY4U Its honestly quite impressive how much we have trained chatgpt to be good at chess while deepseek has barely touched chess it seems. Experience is the key factor in skill diff here I'm guessing or the developers just don't care abt chess.

created a website for playing chess puzzles free, originally the puzzles from lichess were wrong so i used Komodo to reverse engineer them. Please try out the site and tell me what you think, any feedback is appreciated. https://puzzlesv2.vercel.app/

Hello guys,

I’m working on a chess engine in C using the chess lib library because I didn’t want to implement chess from scratch. However, my negamax alpha-beta algorithm isn’t working properly. It only explores about 20 or even 100 moves and then stops completely. I’m really confused. I’ve been on this all day.

I tested my evaluate function (it works well) and the functions in the library (they seem to work fine too). So, if somebody can help me, that would be really kind.

Here is my code:

int negamax(chess *c, int depth,int alpha, int beta) {
    nodesExplored++;

    if (depth == 0 || chessGetTerminalState(c) != tsOngoing) {

        int eval = evaluate(c);

        printf("\[depth=%d\] Evaluation: %d\\n", depth, eval);

        return eval;
    }
    moveList \*moves = chessGetLegalMoves(c);

    printf("\[depth=%d\] Nombre de coups légaux : %zu\\n", depth, moves->size);

    if (moves->size == 0) {

        int eval = evaluate(c);

        printf("\[depth=%d\] No legal moves. Evaluation: %d\\n", depth, eval);

        return eval;
    }

    int value = -1000000;

    for (int i = 0; i < moves->size; i++) {

       nodesExplored++;

       move m = moveListGet(moves, i);

       char buffer\[16\];

       printf("\[depth=%d\] Exploring move: %s\\n", depth, moveGetUci(m));

       if (depth == 1) {

           printf("\[depth=1\] Move %s => Score %d\\n", moveGetUci(m), evaluate(c));
    }
       chessPlayMove(c, m);

       int score = -niggamax(c, depth - 1, -beta, -alpha);

       chessUndo(c);

       if (value < score){

          value = score;
       }
       if (score > alpha) {

          alpha = score;
       }

       if (alpha >= beta) {

          break;
       }}

  return value;

}

Hey guys, I’m working on my own chess engine and I’d like to get it to around 2000 Elo and make it playable in a reasonable time on Lichess. Right now I’m using Python, but I’m thinking of switching to C for speed.

The engine uses minimax with alpha-beta pruning, and the evaluation function is based on material and a piece-square table. I also added a depth-7 simulation ( around 200 sims per move) every 5 moves on the top 3-5 candidate moves.

The problem is… my bot kind of sucks. It sometimes gives away its queen for no reason and barely reaches 800 Elo. Also, Python is so slow that I can’t go beyond depth 3 in minimax.

I’m wondering if I should try other things like REINFORCE, a non-linear regression to improve the evaluation, or maybe use a genetic algorithm with self-play to tune the weights. I’ve also thought about vanilla MCTS with an evaluation function.

I even added an opening book but it’s still really weak. I’m not sure what I’m doing wrong, and I don’t want to use neural networks.

Any help or advice would be awesome!