Wednesday, December 12, 2012

Chess for Android v4.1

I just released version 4.1 of Chess for Android, available at Google Play or as direct download (including a version with network/SMS permissions). The new features include:
  • Ability to send SMS messages (PGN, FEN, UNICODE, engine analysis)
  • Ability to enable/disable built-in book (useful when imported engine book should be preferred)
  • Larger engine analysis font
  • Further localization and internationalization
To send an SMS, long-press the notation window, and select "Send SMS", which pops up the window shown below. Simply fill out the phone number (which will be remembered for next time), and select between PGN, FEN, or UNICODE format (or engine analysis of an imported engine). Pressing the "Send SMS"  button will send the text message. The concise FEN format will be useful for correspondence players, since it can be directly copied and pasted by the other player (I have not implemented an SMS listener yet).

The UNICODE format sends the current chess position using UNICODE characters, as illustrated below (without fixed-width font, this may not always display as nicely).

   ▧   ▧   ▧   ▧
▧   ▧   ▧   ▧   
   ▧   ▧   ▧   ▧
▧   ▧   ▧   ▧   

Saturday, December 8, 2012

Commodore 64 still runs!

Like many others, I learned Basic and 6510 machine code on the Commodore 64, a present from my dear grandfather and parents. Although nowadays one can relive the good old times with emulators, such as CCS64 or Vice, and a cross-assembler, like my own win2c64, nothing beats the real deal!

Today I tried to get my old Commodore 64 and 1541 disk drive, bought in Europa, running again. A few 110-220V adapters, a S-Video cable, and some PAL/NTSC settings later, I have my old friend running again. What made me extra happy is that the 1541 could still read the 5¼" floppy disks with my old programs that I wrote back in the eighties, such as the music editor on the screen shot. I am going to try to copy those onto my hard disk, so others can run these in an emulator.

Sunday, October 28, 2012

BikDam: international checkers

Inspired by Rein Halbersma's kind encouragement, I have started some work on an international checkers engine. After all, "dammen" is the variant I grew up with in The Netherlands. Since I have implemented BikJump for chess, BikMove for American checkers, I decided to name this upcoming engine BikDam.

I already had some fun hacking a, hopefully, efficient move generator. The rules for captures were very interesting to implement. Here are the perft number from the start position of 10x10 international checkers (a.k.a. dammen). In contrast with my American checkers move generator, here duplicate captures are removed.

perft(1) = 9 in 0 ms.
perft(2) = 81 in 0 ms.
perft(3) = 658 in 0 ms.
perft(4) = 4265 in 0 ms.
perft(5) = 27117 in 1 ms. 27117.0 KN/s
perft(6) = 167140 in 3 ms. 55713.3 KN/s
perft(7) = 1049442 in 22 ms. 47701.9 KN/s
perft(8) = 6483961 in 78 ms. 83127.7 KN/s
perft(9) = 41022423 in 434 ms. 94521.7 KN/s
perft(10) = 258895763 in 2599 ms. 99613.6 KN/s
perft(11) = 1665861398 in 17090 ms. 97475.8 KN/s

Monday, September 24, 2012

Perft for Checkers for Depth 28

My quest for deeper perft numbers for 8x8 checkers using has reached depth 28. Below you see the perft(28) breakdown per move, called "divide". As stated before, the numbers were computed on a cluster of machines, optimized with a "hard collision"-free transposition table as well as bulk counting. The move generator does not eliminate duplicate captures.

At this point, the limits of 64-bit unsigned integers have been reached. Although there are obvious ways around these restrictions, this seems a very good time to give this (by now probably insane) project a rest. I have updated this OEIS entry up to depth 26, and may add the higher depths also when I am a bit more comfortable with these most recent results.

12-16 = 2400708339858199191
11-16 = 2431386196712611878
11-15 = 2231787529331259810
10-15 = 2186446356811761737
10-14 = 1872427919495823777
 9-14 = 2285893686261887442
 9-13 = 2969067990365356900
perft(28) = 16377718018836900735

Thursday, September 20, 2012

Perft for Checkers for Depth 27

With the new improvements in place, it would almost be a waste not to go deeper with my perft for checkers computation. Therefore, I computed perft(27) from the initial position of 8x8 checkers. Below you see the perft breakdown per move, called "divide". As stated before, these numbers were computed on a cluster of machines, further optimized with a "hard collision"-free transposition table as well as bulk counting. The move generator does not eliminate duplicate captures.

 move                 divide(27)
 12-16    =  516399283859880203
 11-16    =  519502096014967805
 11-15    =  476666239516455180
 10-15    =  468705060101275533
 10-14    =  400425747281243848
  9-14    =  486493422418651579
   9-13    =  631652334435528457 
perft(27) = 3499844183628002605

The implementation is "fault tolerant" against machine failures. Nevertheless, since I saw a few of these recoveries in this particular run, I may rerun this depth soon to verify the results pedantically.

Tuesday, September 18, 2012

Perft for Checkers for Depth 26

I made some improvements to my distributed implementation for computing perft and divide numbers for 8x8 checkers, and now computed depth 26 from the initial position, shown below. As reported earlier, the numbers were computed on a cluster of machines, further optimized with a "hard collision"-free transposition table as well as bulk counting. The move generator does not eliminate duplicate captures (viz. the situation where a king can capture the same pieces in different directions; a situation that starts to occur at depth 12 and up).

move              divide(26)
12-16:    111362678435231752
11-16:    112590257768420515
11-15:    101352649993886926
10-15:    100552646996749293
10-14:     86312674861234785
 9-14:    103811787278058952
 9-13:    136189763354484914
perft(26) 752172458688067137

Wednesday, September 12, 2012

Perft for Checkers for Depth 25

Continuing my quest for deeper and deeper perft numbers for 8x8 checkers, I now computed depth 25 with the same distributed implementation I used earlier for depths up to 24. Below you see the perft breakdown per move (called "divide") from the initial position for depths 23, 24 and 25 (my depth 23 and 24 numbers were recently kindly confirmed by Murray Cash at the World Draughts Forum).

move          divide(23)        divide(24)          divide(25)
12-16:  1123463594881857  5192042148594780   24019313789608561
11-16:  1131373985922218  5248615918291379   24153215782987793
11-15:   984253557821317  4602138522979438   21659601983574539
10-15:  1000606302770349  4643700995955222   21609957136212495
10-14:   856779998157523  3988937724259353   18496978526984076
 9-14:  1003310451936358  4712325943133747   22101040287502927
 9-13:  1337748969176591  6263620622082081   29027372375205409
        7437536860666213 34651381875296000  161067479882075800

The numbers were computed on on a cluster of machines, further optimized with a "hard collision"-free transposition table as well as bulk counting. Please note that the move generator does not eliminate duplicate captures (viz. the situation where a king can capture the same pieces in different directions; a situation that starts to occur at depth 12 and up).

Wednesday, September 5, 2012

Further Localication

I just released version 4.0.5 of Chess for Android, available through Google Play or as direct download. This release mainly extends localization to more languages, but it also provides a new feature: copying the engine analysis to the clipboard. The following languages are now supported:
  • Afrikaans (af)
  • Chinese (zh)
  • Czech (cs)
  • Dutch (nl)
  • English (en)
  • French (fr)
  • German (de)
  • Hebrew (iw)
  • Hindi (hi)        [coming soon]
  • Icelandic (is)   [coming soon]
  • Italian (it)
  • Polish (pl)
  • Portuguese (pt-br)
  • Russian (ru)
  • Spanish (es)
  • Swedish (sv)
  • Turkish (tr)
Many thanks to my translation team: Vinícius Angiolucci, Lucas Braesch, A.N. Bürümcekci, Panna Chowdhury, Anton Hansson, Arnar Mar Hrafnkelsson, Michal Kaczmarek, Dara Koper, Morgan Lombard, Krizia Lopez, Dennis Prochko, Martin Sedlák, Philip Stutz, Haran Talmon, Ted Wong, and last but certainly not least C.R. Zamana!

Monday, July 23, 2012

Localization of Chess for Android

Version 4.0 of Chess for Android, available at either Google Play or as direct download, focuses on localization and internationalization. All user facing text (except the chess notation and engine messages) has been translated into the following languages.
  • English (the default)
  • Dutch (translated myself)
  • German (many thanks to Philip Stutz)
  • Hebrew (many thanks to Haran Talmon)
  • Polish (many thanks to Michal Kaczmarek)
  • Spanish (many thanks to Krizia Lopez)
  • Swedish (many thanks to Anton Hansson)
If you spot any mistakes, if you would like to see support for other languages or, even better, if you would like to help with further localization, please drop me a private note.

Saturday, July 7, 2012

Scrolling utility for the micro-KIM

I had been working on some general utilities for the micro-KIM, and used some spare time during the long weekend to finish a scrolling putchar utility that can output letters and digits to the 7-segment display in a scrolling fashion (some letters needed more improvisation than others, but my daughter Karina helped me designing all the letters and converting them to hex). Here is a demo.

Thursday, July 5, 2012

DeepBrutePos for Android

Folkert van Heusen is developing a chess engine, called DeepBrutePos, and he also wrote a version for Android. The engine is written in Java, and he used the Android SDK to develop a version that acts as a chess server, so that it can be imported as network socket in Chess for Android (a rather unusual, but nifty use of that feature).

I conducted a quick test with one of the first versions. Below the results of a one-second-per move tournament from both sides of all Nunn opening lines on a Nexus One. I was hoping for better results for Folkert, but hopefully he will release a strong version soon. Good luck!

                       1        2          3         4         5        6                   
1 BikJump v2.1P        *     17.5- 2.5 20.0- 0.0 20.0- 0.0 20.0-0.0 20.0-0.0 97.5/100
2 fairymax48q       2.5-17.5     *     10.0-10.0 12.5-7.5  18.5-1.5 20.0-0.0 63.5/100
3 umax48w           0.0-20.0 10.0-10.0     *     12.0- 8.0 20.0-0.0 20.0-0.0 62.0/100
4 Chess for Android 0.0-20.0  7.5-12.5  8.0-12.0     *     17.0-3.0 20.0-0.0 52.5/100
5 Simplex 0.9.7 180 0.0-20.0  1.5-18.5  0.0-20.0  3.0-17.0     *    20.0-0.0 24.5/100
6 DeepBrutePos v1.6 0.0-20.0  0.0-20.0  0.0-20.0  0.0-20.0  0.0-20.0    *     0.0/100

Friday, June 29, 2012

Chess for Android v3.3

I just released version 3.3 of Chess for Android, available at Google Play or as direct download. The new features include:
  • Ability to modify filenames of regular and tournament games.
  • Information on network status during socket setup.
In the older versions, regular games and tournament games were alway appended to, respectively, the files games.pgn and tour.pgn on SD card. The new feature allows users to change these defaults through a "Change pathnames" menu. The pathnames can even include subdirectories, provides these directories exist.


The second feature displays information on the network status during socket setup (mobile connection, Wifi, etc.). In the version without network permissions (the default on Google Play), a proper warning message is shown instead.


Friday, June 15, 2012

Monitoring Stations in the Bay Area

Below a more detailed view of all monitoring stations in the Bay Area that are part of the radiation network, where my station shows in slightly darker yellow. The station near LLNL usually shows a similar CPM rating, while the one in the South Bay usually shows a bit higher CPM. As long as my station is up, you can also view this real-time map.

Tuesday, June 12, 2012

Radiation Network

I purchased GeigerGraph for Networks from Mineralab, and joined the radiation network, which is a network of volunteers all over the world with radiation monitoring stations that report local CPM (counts per minute) ratings. In the graph below, you can see my station in the East Bay in slightly darker yellow.

I can highly recommend this software. The maps show active monitoring stations all over the world, and one can obtain more detailed information for each station. The software also generates graphs or spreadsheets of measured data, and allows specifying alert actions, such as sending an email, when CPM ratings exceed a certain maximum. The software can also post a real-time map on a server.

Friday, June 8, 2012

Geiger Counter Continued

I investigated the large variation observed in the graph of June 6. While babysitting the monitoring software, I noticed that occasionally the software would report bursts of over 200 CPM, even though the Geiger counter itself never measured such a spike. Two "faulty minutes" in one hour could easily explain the 400 clicks variation. Therefore, I first tried different serial/USB converters (settings were always as specified by the GC manufacturer), since low quality converters are notorious for messing up signals. But I noticed faulty burst even for expensive converters. Then I tried my only computer that still has a serial port. Now, no more faulty bursts occurred during several test runs.

After that, I redid the 24 hours experiment. The results are shown below. A much more stable graph, reporting around 700 CPH, or .1 μSv/hour, which translates into about .9 mSv/year.

I am glad I am now able to perform more reliable measurements. If anyone has suggestions on debugging the serial/USB convertors, please let me know.

Wednesday, June 6, 2012

Geiger Counter

I got a Digital Geiger Counter for my birthday (yes, I know, geeky). As a starter use, I measured the background radiation in our house in the East Bay over the past 24 hours. The results appear in the graph below, plotting the "counts per hour" and corresponding μSv/hour over the past 24 hours. The worst-case measured .2 μSv/hour translates to about 1.8 mSv/year, which luckily seems a bit below the worldwide average background dose.

Tuesday, May 22, 2012

Solar Eclipse 2012

We made a road trip to Mount Shasta and back to view the solar eclipse 2012, Armed with a home-made pinhole camera made by two shoe boxes, we watched the eclipse in a safe way.


Monday, May 21, 2012

The Checker Maven

Bob Newell's The Checker Maven is a very interesting online publication on Checkers and Draughts. This week's issue features checkers applications for Android.

Bob looked at many checkers programs but concluded that the only two application that merit consideration are Checkers Tutor, by world class checker programmer Martin Fierz (author of CheckerBoard and the Cake computer engine), and .... Checkers for Android by yours truly! I am honored to receive this special mention by The Checker Maven.

You can find the summary article at the main page. A more elaborate overview, including interviews with Martin and myself and be found in the full article.

Many thanks to Bob for posting this article.

Tuesday, May 8, 2012

Checkers for Android

Revisiting checkers programming, I just released version 2.5 of Checkers for Android, both at the Google Play and as direct download. New features include:
  • simple animation of captured pieces
  • added a slight delay in single-move response
  • added transposition table to engine
  • more time controls
The new animation and delay will hopefully make it more clear what move was just played. The transposition table should improve the engine strength a bit.

UPDATE: version 2.5.1 improves the animation as shrinking pieces (some users thought the older fading pieces were "drag delay"!), adds more endgame knowledge, and shows kings more clearly.

Friday, April 27, 2012

Tuesday, April 24, 2012

Polyglot for Android

There was an interesting discussion on the TalkChess forum whether a chess GUI running on the Dalvik Virtual Machine could merely support a single protocol, and use an adapter, like Polyglot, to support other protocols. Even though Chess for Android already supports both UCI and XBoard/WinBoard, I was intrigued by the question, and decided to give it a try. First, I compiled the polyglot sources for ARM-based Android devices (I had to make a few source changes to make that work). Then I edited a polyglot.ini file pointing to my own UCI engine bikjump1.8 compiled for ARM:


And gave it a try directly from the command line:

$ ./polyglot_for_android
PolyGlot 1.4.67b by Fabien Letouzey.
st 1
1 -1 0 1 h4
1 +0 0 3 h3
1 +2 0 6 g3
1 +12 0 20 Nh3
1 +17 0 22 Nf3
2 +0 0 46 Nf3 Nf6
3 +17 0 148 Nf3 Nf6 Nc3
4 +0 1 772 Nf3 Nf6 Nc3 Nc6
5 +2 2 1691 Nf3 Nf6 Nc3 Nc6 g3
6 +0 5 3120 Nf3 Nf6 Nc3 Nc6 g3 g6
7 +5 8 6163 Nf3 Nf6 Nc3 Nc6 g3 g6 Bg2
8 +0 14 13282 Nf3 Nf6 Nc3 Nc6 g3 g6 Bg2 Bg7
9 +5 49 57243 Nf3 Nc6 Nc3 Nh6 Nd5 Nf5 b3 g6 Bb2
9 +5 49 81920 Nf3 Nc6 Nc3 Nh6 Nd5 Nf5 b3 g6 Bb2
move g1f3

So far, so good! I then tried the same approach in Chess for Android. After installing the polyglot_for_android binary, polyglot.ini file and of course bikjump1.8, I could start polyglot_for_android as XBoard engine, but under water talking to the UCI engine bikjump1.8. So, in principle, one could simply implement one protocol in the GUI, and rely on the adapter to support the other protocol.

Wednesday, April 4, 2012

Temporary Chess Server

As a follow-up on the previous posting and for users that want to experiment with a remote chess server without setting one up themselves, I have, very temporarily, set up a remote chess server with various engines at ports 2000 through 2005 on Simply type this hostname and one of the ports in Chess for Android and let me know if you were able to connect!

Saturday, March 31, 2012

Connecting Chess for Android to a Remote Server

I have received several questions on how to connect Chess for Android running on an Android device (e.g. a phone) as client to a remote chess server (e.g. a powerful desktop), so I decided to write a small document with detailed instructions.

What you will need:
  • The server software from Bernhard Wallner's chess utilities, suited for your server's operating system (if, say, your desktop runs Windows, you will need to download the Windows version). You do not need to download the client software in this case.
  • The network enabled version of Chess for Android.
On the server, start the engine server software, and construct a new row for every engine you want to run remotely. Assign a name, port number, and select the full path to each engine binary (an executable that runs on the server). You can also supply command line options for starting the engine. Check the active checkboxes and click start when done. This yields something similar to the screenshots below. Here, I have started BikJump on port 1048 and Stockfish on port 1049.

Next, you will have to find the IP address of your server. You can find this, for example, using the ipconfig utility. On a local network, you can also query the router for the IP addresses assigned to different computers. Note that running a globally accessible server behind a firewall requires a setup that is a bit outside the scope of this posting (for example, you may need DDNS if your IP address is assigned dynamically, and you may need to forward ports to your chess server in a router).

On the Android device, which will be your client, start Chess for Android, long press the notation window and then select "UCI and XBoard", followed by "Import Engine", followed by "Network Socket". In the pop-up window, enter the IP address or domain name in Hostname box, and the appropriate port in the Port box. Make sure you also make the correct UCI or XBoard selection. In the example below, my server was running on IP address and I want to connect to stockfish on port 1049. If all has been done well, this pops up the engine setup window. Select the desired parameters (note that the endgame tablebases path name applies to your server, not the Android device) and press done.

That's it! In the screenshots below, you see stockfish running remotely at about 867 KNs. In contrast, a screenshot with stockfish running as native ARM binary on the device is shown as well, running at about 67 KNs.

Monday, March 26, 2012

Chess for Android 3.1.5

I just released version 3.1.5 of Chess for Android, available either at the Android market or as direct download. New features include:
  • Ability to filter PGN games (on player, event, ECO, ELO rating range, or result)
  • Automatically re-import last UCI/Xboard engine on exit-re-entry of application
  • Finger sweep left or right as alternative game navigation
  • Minor improvements in setup position feature

Saturday, March 24, 2012

Filtering on ELO

I got a useful suggestion at the talkchess forum for filtering the ELO rating of players. Rather than allowing individual ranges for white and black, I decided to provide a single range that applies to both the white and black player. In the example below, only games where both players have an ELO rating in the range "1200-1700" will be shown. Leaving the lower or upper field empty effectively makes that field unbounded (for "1200-" means all ELO rating 1200 and above, while "-1700" means all ELO ratings 1700 and below).

Friday, March 23, 2012

Filtering PGN Games

I have extended the game storage features of Chess for Android with the ability to filter PGN games, which is a useful feature when dealing with larger files. To use this feature, long press the notation window and select Game Storage. From there, you see the usual game storage choices, now extended with Filter Game from SD.

After a file has selected, a filter window pops up. Here, you can define a filter involving the white and/or back player, the event, an ECO code, and/or the result of the game.

After the file has been loaded, a window prompts all games that match the filter. The user can subsequently decide what game should be loaded into Chess for Android.

The new feature should be released very soon!

Wednesday, March 7, 2012

Arasan 14.0.1 for Android

Jon Dart released version 14.0.1 of Arasan and Jim Ablett kindly provided a binary for ARM-based Android devices. I did a 1 second per move match from both sides of the Nunn opening suite between version 13.4 and the new 14.0.1 using Chess for Android, which ended in 11-9 in favor of the older version (of course not enough games to say anything conclusive; the match was merely a quick sanity check on the new version).

Monday, March 5, 2012

Chess for Android 3.1.4

It has been quiet for a while, because I was really busy at work, but finally Chess for Android version 3.1.4 has been released, available at the Android market or as direct download. New features include:
  • Position setup improvements
  • Enhanced x-chess-pgn content viewing
  • Option to hide engine's principal variation (useful when playing a real game)
  • Simplified connection with remote UCI/XBoard engine (network version only

Tuesday, February 7, 2012

Chess Puzzles

My eight year old daughter Karina is learning chess and we have gotten into the habit of solving a few mate-in-one puzzles from Laszlo Polgar's book Chess - 5334 Problems, Combinations, and Games every night after homework. She is really enjoying it, especially when we are using an electronic DGT board coupled to Chessbase Fritz. Each time she solves a puzzle, Fritz rewards her by saying "checkmate" with a German accent.

Monday, January 30, 2012

Country Chess Netherlands, first division

BikJump ended at 7th place in Geert Maeckelbergh's Country Chess First Divsion of The Netherlands. After a result like this, I feel the well-known "itch" to go back to work on my chess engine again. But first a few more improvements in Chess for Android.

In any case, thanks for running the tournament Geert.

Virutor Chess for Android

Vaclav Vavra set up a new website for Virutor Chess, an UCI engine available for Windows, ARM-based Android devices (and Linux soon to follow). The Android version imports without any issues in Chess for Android. I also ran a quick tournament between the built-in engine, BikJump, and Virutor. The results are show below.
                         1    2     3
  1 BikJump              *   9.5  10.0   19.5/20
  2 Chess for Android   0.5   *    8.0    8.5/20
  3 Virutor Chess       0.0  2.0    *     2.0.20

Sunday, January 22, 2012

Cheng3 for Android

Another engine that can be imported in Chess for Android just became available. Martin Sedlák released a new version of his engine Cheng3, and Jim Ablett kindly made a binary available for ARM-based Android devices. The engine functions well, although it responds with "no GTB found" for the Gaviota endgame tablebases, even thought the cp4 versions reside in /sdcard/gtb.

The results of a quick tournament with different engines varying in strength is shown below. Quite impressive!

                     1          2          3          4          5        
1 Stockfish 2.1      ********** 1111111111 1111111111 1111111101 1111111111 39.0/40
2 cheng3 1.07 JA     0000000000 ********** 10½0½100½1 11111½0111 1111111111 26.5/44
3 GarboChess3        0000000000 01½1½011½0 ********** 11110½½010 1111111111 21.5/40
4 Daydreamer 1.75 JA 0000000010 00000½1000 00001½½101 ********** 1½11111111 16.0/40
5 BikJump v2.1P      0000000000 0000000000 0000000000 0½00000000 **********  1.0/44

Tuesday, January 17, 2012

Chess for Android 3.1.1

I just released version 3.1.1 of Chess for Android at the Android market and as direct download with the new Setup Position feature.

Update: There was a minor bug in defining the halfmove clock of a position, something that is relevant only for positions affected by the fifty move rule. I have posted a fix in version 3.1.2 on my website (or you can wait for the next release through the market).

Sunday, January 15, 2012

More About Setup Position

I finished the new Setup Position feature, which I hope to release really soon. The board editor allows specifying a full FEN position, that is, a board position together with castling rights, the side-to-move, and possibly an en-passant file and halfmove clock counter (for the fifty-move rule). Touching a piece outside the board changes the "pen" to that piece. Alternative, touching a piece on the board changes the "pen" into that piece, and removes the piece from the board (useful to move pieces on the board to another position).

The landscape and portrait layouts are shown below.