Free in some software for linux

libcomprex library transparently handles automatic compression and decompression of files and archives located locally, online, or even in other compressed archives.

The API is similar to Cs built-in file access functions, which provides a smooth transition to libcomprex.

libcomprex can also open uncompressed files, making it a good replacement for the native file access functions.

libcomprex can currently open ar, bzip2, cpio, gzip, tar, and zip files. It supports basic archive writing in some formats. The API is very volatile, and development should be done against the CVS version.

WMTimer is a dockable alarm clock for WindowMaker which can be run in alarm, countdown timer, or chronograph mode. In alarm or timer mode, you can either execute a command or sound the system bell when the time is reached.
Installation:
This has only been tested and compiled on i386 Linux machines.
Go to wmtimer directory and type:
make
copy the wmtimer binary to a directory in your path.
Wmtimer is configurable through the command line or the GTK GUI.
Enhancements:
- Fixed a bug in the the command line parsing where the color option would conflict with the -c option in some cases.

Python Sudoku is a text and graphical program (gtk interface) to create or resolve sudokus. Python Sudoku can also print a sudoku (1 or 4 sudokus in each page) and write a image (png, jpeg, etc) with a sudoku.

Sudoku, sometimes spelled Su Doku, is a placement puzzle, also known as Number Place in the United States.

The aim of the puzzle is to enter a numeral from 1 through 9 in each cell of a grid, most frequently a 9 x 9 grid made up of 3 x 3 subgrids (called "regions"), starting with various numerals given in some cells (the "givens").

Each row, column and region must contain only one instance of each numeral. Completing the puzzle requires patience and logical ability.

Its grid layout is reminiscent of other newspaper puzzles like crosswords and chess problems. Sudoku initially became popular in Japan in 1986 and attained international popularity in 2005.

CoinXtension offers some additional operators for existing data types of Coin 3D; but more important it extends the linear algebra capabilities of the original framework, by adding the new data type C3Xt_matrix3d, that offers such usefull routines as for eigenvalue or QR-decomposition.
CoinXtension library only depends on Coin 3d and libstdc++, thus it should work on all plattforms on which Coin 3D is available, altough it was developed and tested only on Linux/x86.
This is the first release and the software is still alpha, so dont expect it to be exactly the same in some days or weeks, nor that it works the way you imagined!
Furthermore the development of the library is not really a directed process, but i integrate new features as i come accross things in projects that might usefull in future ones too.
Enhancements:
- Support for Euler angles and many bugfixes.

A Sudoku Solver in C is a console-based Linux program, written in C language, that solves Su Doku puzzles using deductive logic. It will only resort to trial-and-error and backtracking approaches upon exhausting its deductive moves.
Puzzles must be of the standard 9x9 variety using the (ASCII) characters 1 through 9 for the puzzle symbols. Puzzles should be submitted as 81 character strings which, when read left-to-right will fill a 9x9 Sudoku grid from left-to-right and top-to-bottom. In the puzzle specification, the characters 1 - 9 represent the puzzle givens or clues. Any other non-blank character represents an unsolved cell.
The puzzle solving algorithm is home grown. I did not borrow any of the usual techniques from the literature, e.g. Donald Knuths "Dancing Links." Instead I rolled my own from scratch as a personal challenge. As such, its performance can only be blamed on yours truly. Still, I feel it is quite fast. On a 333 MHz Pentium II Linux box it solves typical medium force puzzles in approximately 800 microseconds or about 1,200 puzzles per second, give or take. On an Athlon XP 3000 it solves about 6,600 puzzles per sec. (Solving time is dependent upon degree of difficulty, so YMMV.)
Description of Algorithm:
The puzzle algorithm initially assumes every unsolved cell can assume every possible value. It then uses the placement of the givens to refine the choices available to each cell. I call this the markup phase.
After markup completes, the algorithm then looks for singleton cells with values that, due to constraints imposed by the row, column, or 3x3 region, may only assume one possible value. Once these cells are assigned values, the algorithm returns to the markup phase to apply these changes to the remaining candidate solutions. The markup/singleton phases alternate until either no more changes occur, or the puzzle is solved. I call the markup/singleton elimination loop the Simple Solver because in a large percentage of cases it solves the puzzle.
If the simple solver portion of the algorithm doesnt produce a solution, then more advanced deductive rules are applied.
Ive implemented two additional rules as part of the deductive puzzle solver. The first is subset elimination wherein a row/column/region is scanned for X number of cells with X number of matching candidate solutions. If such subsets (or tuples) are found in the row, column, or region, then the candidates values from the subset may be eliminated from all other unsolved cells within the row, column, or region, respectively.
The next deductive rule examines each region looking for candidate values that exclusively align themselves along a single row or column, i.e. a vector. If such candidate values are found, then they may be eliminated from the cells outside of the region that are part of the aligned row or column.
Note that each of the advanced deductive rules calls all preceeding rules, in order, if that advanced rule has effected a change in puzzle markup.
Finally, if no solution is found after iteratively applying all deductive rules, then we begin trial-and-error using recursion for backtracking. A working copy is created from our puzzle, and using this copy the first cell with the smallest number of candidate solutions is chosen. One of the solutions values is assigned to that cell, and the solver algorithm is called using this working copy as its starting point. Eventually, either a solution, or an impasse is reached.
If we reach an impasse, the recursion unwinds and the next trial solution is attempted. If a solution is found (at any point) the values for the solution are added to a list. Again, so long as we are examining all possibilities, the recursion unwinds so that the next trial may be attempted. It is in this manner that we enumerate puzzles with multiple solutions.
Note that it is certainly possible to add to the list of applied deductive rules. The techniques known as "X-Wing" and "Swordfish" come to mind. On the other hand, adding these additional rules will, in all likelihood, slow the solver down by adding to the computational burden while producing very few results. Ive seen the law of diminishing returns even in some of the existing rules, e.g. in subset elimination I only look at two and three valued subsets because taking it any further than that degraded performance.
Enhancements:
- Code optimization has resulted in a 30% increase in speed.

Twisted Mail project provides client and server implementations of SMTP, POP3, and IMAP4.
These differentiate themselves from the Python standard library implementations both by presenting a much higher-level, easy-to-use interface and in their server components, which allow the implementation of custom servers for each protocol without dealing with protocol-level issues.
Twisted Mail includes a simple demonstration email server which accepts messages over SMTP, stores them in a Maildir arrangement, and can serve them to clients over POP3.
Enhancements:
- The IMAP4 client now properly quotes usernames and passwords when necessary.
- It also handles unsolicited FLAGS responses.
- The IMAP4 server can now parse multiple literals in a single command and to FETCH requests with multiple BODY parts.
- A bug where Deferreds returned from IMAP4 client methods would not receive connection lost notification has been fixed.
- Startup time on OS X has been improved.
- The SMTP server has been sped up.
- The POP3 mailbox API has been expanded to allow Deferreds to be returned in some cases.

cgichk is a Web vulnerability tool that automatically searches for a series of interesting directories and files on a given site. It also includes a whois lookup.
I originally came upon a CGI vulnerability scanning late last year and for fun, decided to rewrite it (Im a sucker for organizing code I didnt write to my own style.) I added more and more to it, and decided to add in some curiousity things to search for, besides the already built in files.
This was NEVER intended to be a tool for being an asshole with. Im just a nosy, curious bastard and have created a tool to automate the search because Im infinitely lazy.
This program does nothing that a person with two hands and a brain couldnt do.
Enhancements:
- Added an option (-H) to retrieve the HTTP header and then quit.
- Began to wonder if this app would be better off using Perl, and then decided against it.
- Added some new targets (well, php versions of old specific targets).
- Added option (-I) to NOT look inside 200s for 404 type strings.

Concede project is a computer version of the board game "Take It Easy".

Concede is a computer version of the board game "Take It Easy". The game is a kind of mix between 4-in-a-row and bingo (aka loto in some place). The player start with an empty board where 19 hexagonal tiles have to be placed. At each turn a random tile is drawn and the player must put it somewhere on the board.

Each tile is marked with 3 numbers (from 1 to 9) and the player must try to make as many complete rows as possible with the tiles he get. The problem is that their is more tiles in the game than places on the board and they come in random order.

When the board is full the game end and the score is computed by adding all the complete rows together. So for example a row of four 5 is worth 20 points, a row of three 9 is worth 27 points, etc.