Free minimax software for linux

Minimax is a Linux distribution which completely fit to an initrd image, because of this it can boot in every situation, which you can imagine.
It is ultra small (32 MB), but very power full. Minimax distribution contains 2.6 kernel with ALL modules and balanced set of console utils, no X server.
Main features:
- Very small, only 32 MB
- Very good hardware support, see kernel config.
- Fits to initrd, can boot on strange SCSI/SATA/USB disks
- Can be added to /boot partition very easy
- System runs from ramdisk
- Contains only console utils, no x server, see packages
- Modern architecture: kernel 2.6, udev with autosymlinks, module autoloading, based on Arch linux
- Based on uclibc and busybox
Some key software:
- Full 2.6.15 kernel with modules, with autodetection and udev. Takes about 60% of livecd size.
- Installer for Arch linux
- wifi drivers and utils: hostap,wlan-ng, madwifi, ndiswrapper...
- Grub as main bootloader
- Midnight Commander
- Links2 - text and graphic web browser
- FBI - an image viewer
- IRSSI - an irc client
- CenterICQ - an excelent client for icq,msn,jabber...
- Music on console - player with mp3,ogg and online streaming support
- Bash burn - an cd record console frontend
- Partimage - disk mirroring tool
Minimum requirements:
- 64 MB RAM (system needs 32 MB big ramdisk).
- An i386 or better processor.
- Hardware compatible with 2.6.15 kernel, for very old computers (486) is Damm small linux or Puppy linux better choice, becouse of 2.4 kernel
How was it made?
I take uclibc and busybox (software for embedded linux) and compile base system from scratch. I add initscripts from Arch linux, they are very easy to understand and modify. With some other software and modular kernel 2.6 I got system with about 70 MB. After compression with squashfs I got 30 MB big initrd image. Now it was easy to create an CD image.
Packages
minimax , bash, busybox, dhcpcd, e2fsprogs, filesystem, gpm, initscripts, kdm, kernel, libz, module-init-tools, ncurses, net-utils, sysvinit, uclibc, udev, utils, archsetup, snarf, rsync, vsftpd, dd_rescue, dd_rhelp, dosfstools, ext2resize, grub, jetcat, jfsutils, lilo, ntfsprogs, parted, partimage, reiserfsprogs, squashfs-tools, xfsprogs, bastet, enigma, fbi, libexif, libgif, libjpeg, libpng, links, libbz2, libc++, libcom_err, libexpat, libnet, libpcap, libpcre, libtool, *, alsa-lib, alsa-utils, bashburn, cdrdao, cdrtools, dvd+rw-tools, libao, libid3tag, libmad, libogg, libvorbis, moc, shfs, biew, centericq, glib, htop, irssi, mc, nano, ncurses, nstats, screen, dnstracer, iplog, iptables, libpcap, netcat, ngrep, nmap, openssh, openssl, tcpdump, autossh, bc, curl, file, hdparm, pciutils, ppp, pv, raidtools, tcptraceroute, wget, x86info, atmel-firmware, drivers_in_kernel, hostap-utils, ipw2100-firmware, ipw2200-firmware, linux-wlan-ng, linux-wlan-ng-firmware, linux-wlan-ng-utils, madwifi-tools, ndiswrapper, prism54-firmware, wireless-tools, zd1201-firmware, zd1211

AlphaBeta is a framework that implements MiniMax search with Alpha-Beta pruning and is designed to make it simple to create two-player zero-sum perfect information games in Objective-C.

Both fixed-depth and iterative search is supported.

I created this project using Xcode, and the project checkout also includes the Reversi and TicTacToe frameworks. These are used in AlphaBetas test suite. The Reversi framework is additionally used by Desdemona, a Reversi game using AlphaBeta for its AI.

Shatranj is an bitboard-based, Open-Source, interactive chess programming module which allows manipulation of chess positions and experimentation with search algorithms and evaluation techniques. Shatranjs goal is to write a toolkit to aid in implementing Shannon Type B chess programs.

As such, execution speed becomes less important then code clarity and expressive power of the implementation language. Having been written in an interpreted language, this module allows the chess programmer to manipulate bitboards in a natural, interactive manner much like signal processing toolkits allow communication engineers to manipulate vectors of sounds samples in MATLAB.

The module currenly implements a simple recursive minimax search with alphabeta pruning, iterative deepening, uses short algebraic notation, handles repetition check, and the 50 move rule. Features lacking are quiescent checks, transition tables, negascout and MTD searching.

The chess programming toolkit is available in the form of a Python module called shatranj.py. You will also likely need the opening book as well as some of the pre-built hash tables that are used throughout the module (these will be recalculated if the module cannot find the data file).

Place all three file in the same directory and simply run python on the python module ("python shatranj.py"). As far as requirements, all that is needed is a recent version of the interpreted, high level language called Python (anything after version 2.3 should work fine). If you would like a little bit of a speed boost, shatranj looks for the module Psyco and will use it if it is installed.

Until more documentation becomes available, here is a short sample session:
[Sam-Tannous-Computer:~/shatranj] stannous% python

>>> from shatranj import *
...reading startup data
...total time to read data 0.0774528980255
...found opening book shatranj-book.bin with 37848 positions
>>> position = Position("r1bqk2r/pppp1ppp/2n5/5N2/2B1n3/8/PPP1QPPP/R1B1K2R")
>>> all_pieces = position.piece_bb["b_occupied"] | position.piece_bb["w_occupied"]
>>> other_pieces = position.piece_bb["b_occupied"]
>>> from_square = c4
>>> wtm = 1
>>> mask = position.pinned(from_square,wtm)
>>> ne_pieces = diag_mask_ne[from_square] & all_pieces
>>> nw_pieces = diag_mask_nw[from_square] & all_pieces
>>> moves = ((diag_attacks_ne[from_square][ne_pieces] & other_pieces) |
... (diag_attacks_ne[from_square][ne_pieces] & ~all_pieces) |
... (diag_attacks_nw[from_square][nw_pieces] & other_pieces) |
... (diag_attacks_nw[from_square][nw_pieces] & ~all_pieces)) & mask
>>>
>>> moves
1275777090846720L
>>>
>>> tobase(moves,2)
100100010000101000000000000010100000000000000000000
>>> display(moves)

+---+---+---+---+---+---+---+---+
8 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
7 | . | | . | | . | 1 | . | |
+---+---+---+---+---+---+---+---+
6 | 1 | . | | . | 1 | . | | . |
+---+---+---+---+---+---+---+---+
5 | . | 1 | . | 1 | . | | . | |
+---+---+---+---+---+---+---+---+
4 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
3 | . | 1 | . | 1 | . | | . | |
+---+---+---+---+---+---+---+---+
2 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
1 | . | | . | | . | | . | |
+---+---+---+---+---+---+---+---+
a b c d e f g h

>>> position.show_moves(1)
[Rg1, O-O, f3, a3, Rb1, f4, Ba6,
Bh6, Bd3, Qg4, Qe3, Ne7, Be6, Nxg7,
Qxe4, Ne3, b4, Nh4, b3, Be3, Bg5,
g3, Kf1, Rf1, Nh6, a4, Ng3, Qh5,
Kd1, h4, h3, c3, Bxf7, Nd6, Bb5,
Nd4, Qf3, g4, Qf1, Bb3, Qd1, Qd3,
Qd2, Bd5, Bd2, Bf4]
>>>
>>> # now play a game!
>>> play()

Shatranj version 1.10
g: switch sides m: show legal moves
n: new game l: list game record
d: display board b: show book moves
sd: change search depth (2-16) default=5
q: quit

Shatranj: d

+---+---+---+---+---+---+---+---+
8 | r | n | b | q | k | b | n | r |
+---+---+---+---+---+---+---+---+
7 | p | p | p | p | p | p | p | p |
+---+---+---+---+---+---+---+---+
6 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
5 | . | | . | | . | | . | |
+---+---+---+---+---+---+---+---+
4 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
3 | . | | . | | . | | . | |
+---+---+---+---+---+---+---+---+
2 | P | P | P | P | P | P | P | P |
+---+---+---+---+---+---+---+---+
1 | R | N | B | Q | K | B | N | R |
+---+---+---+---+---+---+---+---+
a b c d e f g h


Shatranj:

cddsolve project is a double dummy bridge solver.
It utilizes alpha-beta pruning and minimax searching to find the number of tricks a given side can take under the assumption of optimal play.
While the complexity of the problem may be enormous depending on the given deal and contract, cddsolve is fast enough to be actually helpfull for many double dummy bridge problems.
cddsolve has an predecessor called ddsolve which is implemented in python and also available on this page.
ddsolve is considered to be a prototypical implementation to demonstrate the basic algorithms and quantify the impact of different optimizations.
Enhancements:
- cleaned up the preprocessor macros and added some bogus return values to make recent gccs happy.
- incremented the TPBUCKETCOUNT in ddtranspos.c, trading computational speed against memory footprint. shoe size is about 10mb larger now.
- released 0.9.