Free over 40 software for linux

Xoridor is a strategic board game.

In this game the player needs to get across the board as quickly as possible while making sure no fences get in her way.

Panzers project is a simple 3D multiplayer tank game.
The player controls a WW2 tank. The player controls the tank in a fully 3D environment trying to blast other players.
Several different vehicles will be selectable, but currently there are two different panzers at your disposal.
Main features:
- multiplayer action through a server (still flaky at best though)
- full 3D environment with lakes, houses and woods
- panzers can be fully controlled, including turrets, and they have different characteristics
- some kind of physics approximation for shells
- loads of bugs
- maps can be created by just editing a grayscale png file
At present Panzers is more a technology demo than something youd want to spend too much time playing. Better playability will be added sooner or later. Help is appreciated, of course.

Tess is a C++ library that helps automate final assembly of tedious graphic design tasks (e.g. from photoshop or gimp), such as conjuring piles of web page-specific navigation features.

The project can composite an arbitrary stack of RGBA images, draw antialiased TrueType text (via FreeType), and generate a few shapes and effects. It groks PPM and PAM files, and includes a Perl binding.

WorkBone is a simple, curses-based CD player that is controlled by the num-lock keys. It uses the cdtool package can be used to determine the contents of a CD before playing it.

WorkBone uses the numeric keypad as a control panel to allow you to move track to track, play, stop, pause, and resume playing of audio CDs. Additionally, the running times are continuously updated and displayed. Make sure you have your NUM LOCK engaged when using WorkBone. A template is displayed to guide you, and pushing the DEL key on the numeric pad will bring up a help screen.

Shell over ICMP consists of two free and open source applications: one server and one client. Shell over ICMP project allows a user to connect to a remote shell daemon, by using ICMP protocol instead of classical TCP.
Entirely written in Python, soicmp is a working proof-of-concept to demonstrate that data can be transmitted across a network by hiding it in traffic that normally does not contain payloads.
How does it work?
The soicmp server is a daemon that must be started on the remote server. When the server receives a request from the client it looks into the packets payload. The payload must respect certain protocol rules. In detail the client must specify:
command
communication mode (echo|echo/reply)
authentication (y|n)
This is an example of a correct payload string sent by client to server:
$CMD ls -a $MODE echo/reply $PWD root2005 $END
If the payload matches with the server protocol specification then it will pipe the command to "/bin/sh" or "cmd.exe" and execute it. The server then reads the result from the pipe and sends it back to the client that will print it to stdout.
Moreover every client will send ICMP packets having id equal to the clients current process ID and will accept only ICMP replies having the same id value. This prevents output to be printed by other client instances running on the same workstation (this argument is also treated in the FAQs section).
Main features:
- Platform independent.
- Possibility to run soicmp daemon on multiple ethernet interfaces simultaneously handling multiple client connections.
- Possibility to specify the buffer size of outgoing packets.
- Client side source IP address spoofing.
- Remote client case-sensitive (plain texted) authentication.
- Possibility to select two communication types:
- One based on encapsulating command output in unique "one way" ICMP_ECHOREPLY (type 0) packets sent by server to client (see fig. 1).
- Another one that guarantees the correct packets delivering by using the request/response nature of ECHO and ECHOREPLY ICMP packet types (see fig.2)
- No listening sockets are listed by netstat or similar programs.

MikeOS is an operating system for x86 PCs, written entirely in assembler. Its not intended to to become a fully-fledged general purpose OS -- instead, its designed for learning basic OS design and x86 assembly language. Consequently, it runs in 16-bit mode (for BIOS access) and has very low system requirements.
Current features include: FAT12 floppy disk reading; menu-based program selector; command-line interface; 26 system calls (eg screen and string handling); rudimentary DOS compatibility; an API for developers; example programs and more. To run MikeOS, download the compressed archive from the links below -- this includes the full source code and disk images.
Enhancements:
- Many new DOS compatibility functions from Peter Nemeth.
- Initial printer and serial modem support.
- Store and reload registers when launching DOS programs.
- VisiCalc now loads.

Head Over Heels is a spanky new remake of the classic Jon Ritman & Bernie Drummand isometric adventure.

Head Over Heels was released, um, a while ago. Around about 1987 if I recall correctly and it was immediately praised in the press as being quite the bestest thing ever. Not only was it a huge game for its time, it also had great graphics and was very addictive - if somewhat punishing in its difficulty level.

The variety in the locations was amazing and the challenges brilliantly designed. Quite rightly it was awarded with pretty much every accolade that could be bestowed upon it by the various magazines. Even today it still stands as a brilliantly designed title and has never really been bettered in the isometric adventure genre.

This version is a pretty darn faithful remake of the Speccy original except with a few spanking extra bits grafted on like a save system and subliminal flashes of erotic art (if I have my way!). I should perhaps tell you a bit about the team whos making the game. Im the one responsible for the graphics (apart from the lovely logo which you see adorning this site) and Im Graham Goring.

The programming is by the very talented Tomaz Kac (who only wrote this game because of a hastily scrawled diagram posted on the Retrospec mailing list about how you cant properly sort isometric games without complex masking), the excellent music is by Dorian Black (who I understand has a picture of an old man in his loft - ha ha ha!) and this website and the games logo is by Pierre Jovanovic.

Other contributors are James Curry, Kakarot, Milos Babovic, Metka Jostl and Sir Dave-O whose beta testing has been invaluable in both ironing out the programming bugs and also refining the layout of some of the rooms due to the handling being ever so slightly different to the Spectrum version.

On a personal note Ive also been encouraged by all the lovely people at the pixelation forum (pixelation.swoo.net) and of course the other members of Retrospec who have now grudgingly accepted that I can actually draw fairly good graphics.

Network Pipemeter is a tool for measuring available bandwidth between hosts. nepim is also useful to generate network traffic for testing purposes.
nepim operates in client/server mode, is able to handle multiple parallel traffic streams, reports periodic partial statistics along the testing, and supports IPv6.
nepim has been tested under Linux, Solaris and FreeBSD, though it should work under other platforms as well. If you manage to build nepim for different systems, please send the patch.
- nepim is useful to assess the throughput at the transport layer (TCP or UDP) as seen by applications.
- nepim runs single-threaded and should impose very light burden on your CPU. Unless, of course, your testing hosts have relatively high network bandwidth compared to low CPU power.
- One single server can service multiple clients simultaneously.
- As of nepim 0.11, one single client can interact simultaneously with multiple servers. For instance, suppose you want to test, from a single client, two remote servers, one located at 10.0.0.1,2000 and another at 192.168.0.1,3000:
- nepim -c 10.0.0.1,2000/192.168.0.1,3000
- The server listens to both TCP and UDP sockets. The client by default uses TCP sockets. Use the "-u" client option to switch the client operation to UDP.
- By default, only the server sends traffic towards the client. Use the "-s" client option to reverse the behavior, then only the client will send traffic. Use the "-d" client option to make both client and server to send traffic.
- Use the "-r" client option to establish an upper bit rate limit. Without a rate limiting option, nepim sends as fast as possible. See also "-R" below. Please notice the rate is specified in bps (bits per seconds); for instance, the following example states a rate limit of 100,000 bps (100 Kbps):
- nepim -c 10.0.0.1 -r 100000
- Use the "-R" client option to establish an upper "packet" rate limit (outbound rate limit for transport layer segments). Without a rate limiting option, nepim sends as fast as possible. If both "-r" and "-R" are given, nepim limits the sending rate at the lower of those bounds.
- Use the "-n" client option to run multiple parallel traffic streams.
- Use the "-b" server option to make the server to listen on specific local addresses.
- Use the "-6" option to disable IPv6 support.
Enhancements:
- Support for randomizing the UDP destination address/port has been added in order to put stress on routers with on-demand (dynamic) forwarding table caches.