Free million musician challenge software for linux

The Million Musician Challenge is a project to allow you to play music by playing games. The first game is a 2D vertically scrolling shoot-em-up game.

The keyboard (qwerty or musical) controls an array of sprites corresponding to the music notes. As you shoot the falling sprites, you play notes corresponding to the music.

HPC Challenge is a high performance benchmark suite. The HPC Challenge consists of basically 7 benchmarks:
1. HPL - the Linpack TPP benchmark which measures the floating point rate of execution for solving a linear system of equations.
2. DGEMM - measures the floating point rate of execution of double precision real matrix-matrix multiplication.
3. STREAM - a simple synthetic benchmark program that measures sustainable memory bandwidth (in GB/s) and the corresponding computation rate for simple vector kernel.
4. PTRANS (parallel matrix transpose) - exercises the communications where pairs of processors communicate with each other simultaneously. It is a useful test of the total communications capacity of the network.
5. RandomAccess - measures the rate of integer random updates of memory (GUPS).
6. FFTE - measures the floating point rate of execution of double precision complex one-dimensional Discrete Fourier Transform (DFT).
7. Communication bandwidth and latency - a set of tests to measure latency and bandwidth of a number of simultaneous communication patterns; based on b_eff (effective bandwidth benchmark).
Compiling:
The first step is to create a configuration file that reflects characteristics of your machine. The configuration file should be created in the hpl directory. This directory contains instructions (the files README and INSTALL) on how to create the configuration file. The directory hpl/setup contains many examples of configuration files. A good approach is to copy one of them to the hpl directory and if it doesnt work then change it. This file is reused by all the components of the HPC Challange suite.
When configuration is done, a file should exist in the hpl directory whose name starts with Make. and ends with the name for the system used for tests. For example, if the name of the system is Unix, the file should be named Make.Unix.
To build the benchmark executable (for the system named Unix) type: make arch=Unix. This command should be run in the top directory (not in the hpl directory). It will look in the hpl directory for the configuration file and use it to build the benchmark executable.
Configuration:
The HPC Challange is driven by a short input file named hpccinf.txt that is almost the same as the input file for HPL (customarily called HPL.dat). Refer to the file hpl/www/tuning.html for details about the input file for HPL. A sample input file is included with the HPC Challange distribution.
The differences between HPL input file and HPC Challange input file can be summarized as follows:
- Lines 3 and 4 are ignored. The output always goes to the file named hpccoutf.txt.
- There are additional lines (starting with line 33) that may (but do not have to) be used to customize the HPC Challenge benchmark. They are described below.
The additional lines in the HPC Challenge input file (compared to the HPL input file) are:
Lines 33 and 34 describe additional matrix sizes to be used for running the PTRANS benchmark (one of the components of the HPC Challange benchmark).
- Lines 35 and 36 describe additional blocking factors to be used for running PTRANS benchmark.
Just for completeness, here is the list of lines of the HPC Challanges input file with brief descriptions of their meaning:
- Line 1: ignored
- Line 2: ignored
- Line 3: ignored
- Line 4: ignored
- Line 5: number of matrix sizes for HPL (and PTRANS)
- Line 6: matrix sizes for HPL (and PTRANS)
- Line 7: number of blocking factors for HPL (and PTRANS)
- Line 8: blocking factors for HPL (and PTRANS)
- Line 9: type of process ordering for HPL
- Line 10: number of process grids for HPL (and PTRANS)
- Line 11: numbers of process rows of each process grid for HPL (and
PTRANS)
- Line 12: numbers of process columns of each process grid for HPL
(and PTRANS)
- Line 13: threshold value not to be exceeded by scaled residual for
HPL (and PTRANS)
- Line 14: number of panel factorization methods for HPL
- Line 15: panel factorization methods for HPL
- Line 16: number of recursive stopping criteria for HPL
- Line 17: recursive stopping criteria for HPL
- Line 18: number of recursion panel counts for HPL
- Line 19: recursion panel counts for HPL
- Line 20: number of recursive panel factorization methods for HPL
- Line 21: recursive panel factorization methods for HPL
- Line 22: number of broadcast methods for HPL
- Line 23: broadcast methods for HPL
- Line 24: number of look-ahead depths for HPL
- Line 25: look-ahead depths for HPL
- Line 26: swap methods for HPL
- Line 27: swapping threshold for HPL
- Line 28: form of L1 for HPL
- Line 29: form of U for HPL
- Line 30: value that specifies whether equilibration should be used
by HPL
- Line 31: memory alignment for HPL
- Line 32: ignored
- Line 33: number of additional problem sizes for PTRANS
- Line 34: additional problem sizes for PTRANS
- Line 35: number of additional blocking factors for PTRANS
- Line 36: additional blocking factors for PTRANS
Enhancements:
- This version contains many bugfixes, major features, and minor enhancements, many of which were contributed by users.
- The major focus of this release was to improve accuracy of the reported performance results and ensure scalability of the code on the largest supercomputer installations with hundreds of thousands of computational cores.

Ultimate Basketball Challenge is a 5 on 5 basketball game for Unix variants including Linux and FreeBSD. Ultimate Basketball Challenge aims to be fully customizable (add/edit teams, players, stats, courts, arenas, etc.).
You can currently play against the basic AI. It is in constant heavy development and new features are added often.
Here you will find instructions on how to use the game.
When you run the ubc binary you will first be presented with the title screen "Ultimate Basketball challenge. Here you ant to press the s key to start.
Now you come to the "Start A New Game" menu. Right now the only options that are usable are "t" for Selecting a team, "s" to start the game or "r" to return ot the main menu.
Team Selection - If you press the "t" key you will be presented with a screen that allow syou to select a new team for either player. First you must either press 1 or 2 to chose which player youre selecting the team for. Then you use the Left and Right arrows on the arrow pad to select your team. When you are done, press the "r" key to return to the "Start A New Game Menu"
Start Game - Press the "s" key from the "Start A new Game" menu to start the game. You will be briefly presented with a list of each team name and a list of players on that team.
In Game controls:
Movement - Use the arrow pad to move the player around. If he has the basketball, it will be drawn in front of the player as they move.
Shooting - Press the "s" key to shoot the ball at the basket.
Exiting the game - press the q key twice to exit Ultimate Basketball Challenge.
Enhancements:
- The code was completely rewritten in C++ and restructured to use the SDL library instead of the Allegro Game Programming library.
- A basic menu system was added and most of the graphics were redone.

Thousand Parsec is a 4 Xs game (eXplore, eXpand, eXterminate, eXploit) but it is different in the sense that it is designed for long games supporting universes as large as your computer can handle. (Have a quad Xeon with 4 gig of ram? Well have a couple of million systems in your universe!.

Thousand Parsec also supports long term play with players joining and leaving throughout the game. As well the tech tree is easily expandable and can be extended during the game without effecting anybody already playing (ie introduction of new technology as the game progresses).

You can choose to have highly exotic universes where the laws of physics are totally different or universes that are very similar to our own.

The game is TURN BASED, this means that clicking quickly isnt vital but strategy is.

The game should also be highly extend-able. Allowing player customisation not found in the commercial games.

Anyway we have high hopes for what TP will become. We have currently stolen a lot of ideas from Stars!, VGA Planets an XPace.

Block Rage will be a falling blocks game with detailed graphics and animated plasmatic backgrounds.
You will be able to challenge your friend in a 2-player hotseat mode! It is strongly inspired by a superb DOS classic.
At present, the game is fully playable, but theres no real graphics nor sounds and absolutely no music.
Enhancements:
- New tile graphics
- Enhanced 2-player screen
- Improved sound module
- Fixed caps lock handling
- Sets window caption
- Other fixes

C Minimal Perfect Hashing Library encapsulates the newest and more efficient algorithms in an easy-to-use, production-quality, fast API. The library was designed to work with big entries that cannot fit in the main memory. It has been used successfully for constructing minimal perfect hash functions for sets with more than 100 million of keys, and we intend to expand this number to the order of billion of keys.
Main features:
- Fast.
- Space-efficient with main memory usage carefully documented.
- The best modern algorithms are available (or at least scheduled for implementation :-)).
- Works with in-disk key sets through of using the adapter pattern.
- Serialization of hash functions.
- Portable C code (currently works on GNU/Linux and WIN32 and is reported to work in OpenBSD and Solaris).
- Object oriented implementation.
- Easily extensible.
- Well encapsulated API aiming binary compatibility through releases.
- Free Software.
A perfect hash function maps a static set of n keys into a set of m integer numbers without collisions, where m is greater than or equal to n. If m is equal to n, the function is called minimal.
Minimal perfect hash functions are widely used for memory efficient storage and fast retrieval of items from static sets, such as words in natural languages, reserved words in programming languages or interactive systems, universal resource locations (URLs) in Web search engines, or item sets in data mining techniques. Therefore, there are applications for minimal perfect hash functions in information retrieval systems, database systems, language translation systems, electronic commerce systems, compilers, operating systems, among others.
The use of minimal perfect hash functions is, until now, restricted to scenarios where the set of keys being hashed is small, because of the limitations of current algorithms. But in many cases, to deal with huge set of keys is crucial. So, this project gives to the free software community an API that will work with sets in the order of billion of keys.
Probably, the most interesting application for minimal perfect hash functions is its use as an indexing structure for databases. The most popular data structure used as an indexing structure in databases is the B+ tree. In fact, the B+ tree is very used for dynamic applications with frequent insertions and deletions of records. However, for applications with sporadic modifications and a huge number of queries the B+ tree is not the best option, because practical deployments of this structure are extremely complex, and perform poorly with very large sets of keys such as those required for the new frontiers database applications.
For example, in the information retrieval field, the work with huge collections is a daily task. The simple assignment of ids to web pages of a collection can be a challenging task. While traditional databases simply cannot handle more traffic once the working set of web page urls does not fit in main memory anymore, minimal perfect hash functions can easily scale to hundred of millions of entries, using stock hardware.
As there are lots of applications for minimal perfect hash functions, it is important to implement memory and time efficient algorithms for constructing such functions. The lack of similar libraries in the free software world has been the main motivation to create the C Minimal Perfect Hashing Library (gperf is a bit different, since it was conceived to create very fast perfect hash functions for small sets of keys and CMPH Library was conceived to create minimal perfect hash functions for very large sets of keys). C Minimal Perfect Hashing Library is a portable LGPLed library to generate and to work with very efficient minimal perfect hash functions.
Enhancements:
- This release adds an implementation of a classical minimal perfect hash algorithm called fch.
- This is used as a basis for a new algorithm that can create minimal perfect hashes for billions of keys with less than four bits per key, and is ready to use.
- Suggestions and bugfixes from users have been incorporated.

Clustermines is a minesweeper game in Java.
Main features:
Cluster-mines
- Mines are bigger. More numbers for your mental calculator.
Flagless mode
- Want a challenge?
Safe border mode
- A mine field with its perimeter already cleared. If you dont like those 50%/50% chances on border, try this.
Practice mode
- Dont worry about dying!
Replaying
- I hope this works in real life too. Honestly.

locust project is a full featured Internet search engine specifically designed for knowledge area or corporate search.
It can index 2.5 million documents per 24 hours on a single Dell server. It consists of clean C++/STL code written from scratch.
Enhancements:
- This release adds minor changes needed to compile with GNU c++ version 4.1.2 and modifications to run on the x86-64 architecture.
- lcreatedb has been improved; the MySQL account password is no longer required and the root password is not echoed.
- The documentation has been broadened and partly rewritten.