When I was 17, I built a Java Chess AI for a school project called Chessmate. The AI couldn't castle or en passant, but it won a regional prize that got lost in the mail.

10 Years later, the code (which I had put on GitHub) made its way into a Minecraft mod called MineChess: http://petrustheron.com/posts/chessmate.html

Source code: https://github.com/theronic/chessmate

You need to switch your data representation to 0x88 [1] or bitbords [2] to get anything performant. You won't get anywhere with a class hierarchy

[1] https://www.chessprogramming.org/0x88 [2] https://www.chessprogramming.org/Bitboards

If someone just wants a library to power a chess UI this isn't really necessary. Either way I'd suggest the author finish off the current implementation until they can get perft and other automated tests up and running first.

That said, chess programming is a _wonderful_ education in Computer Science, and you'll be following in the footsteps of so many great figures in the industry. Understanding bitboards and how to work with them can take you all the way from the bit-twiddling chapters of The Art of Computer Programming, right up to recent advances in CPU architecture and instruction sets. Learning how search works will teach you both very low techniques and high level heuristics in performance optimisation. And of course you can go all all the way up to recent advances in evaluation from deep learning.

You need to consider the goals of a project before giving advice.

OP mentions chess AI and game analyzer. Those would benefit from an optimized data representation.

But both can also be written optimizing for simplicity and clarity at the cost of performance.

Competing with the state of the art is not an implicit goal for every project.

Perhaps they don’t need anything performant? You don’t need a bitboard for everything. (They’re also not always performant.)

Yea and you probably also need OpenCL or CUDA and several GPUs to get anything really “performant”. The basic OO model is good for its own purposes

If the API is well written, this is an implementation detail.

Well, it depends on the project goals. For a GUI app I can agree but good luck writing a chess engine where data representation is hidden behind an abstract interface.

Abstract as in using bit-boards or proper abstraction as in giving a clean interface to interact with a model and let the implementation worry about itself?

The first thing you'd want to implement is perft: https://www.chessprogramming.org/Perft_Results It actually doubles as a performance test(like it's name) and a debugging tool to verify that you can generate moves correctly by comparing your numbers vs the positions given on the website and a few large suites.

I'd encourage you to get involved with the passionate community at talkchess: http://talkchess.com/forum3/index.php

And join a small group on IRC at Freenode ##chessprogramming where we discuss chess AIs, libraries and often other games like Ataxx and Go.

I myself am an author of a chess library: https://github.com/Mk-Chan/libchess ! Great to see development for Java as well

There is also http://www.chesspresso.org/ which worked great for PGN and FEN processing.

Official author GitHub repository: https://github.com/BernhardSeybold/Chesspresso

Has had some very minor fixes since the last source forge version.

Hats off to you for tackling such a hard problem. Coding chess is a beast.

I cut you this one issue, https://github.com/jaeheonshim/ChessBoard/issues/1

I think your castling logic is incomplete? Worth a double check.

You can check also my lib magnus4j for some ideas: https://github.com/johnathana/magnus4j

I loved building my chess library and would encourage other developers to try it. It is large and complex enough to test your abilities. Building it in a idiomatic, testable, and performant way really encourages software engineering skills instead of just coding. I felt like I didn’t really write solid go code until I finished my chess library.

https://github.com/notnil/chess

As someone who has implemented online multiplayer tbs games before, this is exactly the kind of thing you would use at the backend.

However, you also need the same code running on the frontend in order to do validations before sending moves to the backend. That optimization helps distribute some server load and gets you immediate feedback. In Java's case, I'd use some java to js or java to kotlin to js transpilation.

Is performing chess validations that heavy, if you're serving ~10,000 games? (just asking for a friend)

To do all validations and move suggesions on the server side causes data traffic for no reason. Not just cpu time. It is senseless.

As a clarification, of course you will validate all moves on the server side and make sure client side state is consistent, but what I meant by validation is when you have to give every feedback from the server back to the client you will quickly find yourself in a ddos situation with so many players online.

Nice, great to see more open source efforts on Chess. GitHub is down and I can’t quite tell what is the need you are trying to address with this library.

GitHub is down at the worst possible moment for me... Hopefully they'll fix it up soon

Could be nice to see the board.toString() with a Unicode representation of the board.

Edit: the comment text does not allow Unicode characters.

Interesting. What is the reason for starting a new project in Java if much better alternatives such as Rust or Kotlin exist?

Cool, thanks for sharing. I'll check it out once github is back up :-)

Awesome, I would encourage turn this into a actual chess game using JavaFX.

That's a great idea, I'm going to look into creating an online chess game application soon!

Hey, yo! I was thinking doing the same. I was thinking in something with link sharing i.e. you create a game session and then get a link you can share with the second player and spectators.

Good job, you crashed GitHub.