Free runs with scissors software for linux

runsuid runs a script with another user-id/group-id, when the user has the right to do so according to the configuration file.
If used in the right combination with access restrictions this can ease the life of system administrators. Additionally, it can be used for running CGI-scripts as different fixed users.
Enhancements:
- A stupid options parsing bug and a memory leak (with no security implications) were fixed.
- Spelling corrections were made.

WMsensors.pl is a small perl-program which monitors the temperature and voltages of CPU and motherboard and also shows the Fan-speed.

Runs as a dock app for Window Maker.

Needs no config-file, but a proper configured installation of lm_sensors and uses the Wharf::JDockApp modul from the CPAN.

Critical Mass (aka Critter) is an SDL/OpenGL space shootem up game. Critical Mass project currently runs on Mac OS X, Windows, and Linux.

The latter is my main development platform. Other platforms supported by SDL/OpenGL may also work with a bit of work.

IPC::Run::Simple is a simple system() wrapper.

SYNOPSIS

# Run a command and check whether it failed
use IPC::Run::Simple;
run("echo Hello, O Cruel World")
or die "Command failed";

# Describe the failure
use IPC::Run::Simple qw($ERR);
run("echo Hello, O Cruel World")
or die "Command failed: $ERR";

# Use the :all tag instead of explicitly requesting $ERR
use IPC::Run::Simple qw(:all);
run("echo Hello, O Cruel World")
or die "Command failed: $ERR";

# Die with error message if command does not return 0
use IPC::Run::Simple qw(:Fatal);
run("echo Hello, O Cruel World");

# Allow other exit values without dying
use IPC::Run::Simple qw(:Fatal);
run(command => [ "echo", "Hello, O Cruel World!" ],
allowed => [ 1, 2, 5 ]);

This module is intended to be a very simple, straightforward wrapper around the system() call to make it behave more like other builtins.

run() will return a true value if the command was executed and return a successful status code, and false otherwise. The reason for the failure will be stored in the $IPC::Run::Simple::ERR variable (which is just $ERR if you import either $ERR or :all). The description of the reason was pulled almost directly from the system() documentation.
Optionally, you can import the :Fatal tag, which will cause run() to die() with an appropriate message if the command fails for any reason.

If you wish to allow nonzero exit values but still want to trap unexpected errors, you may use an expanded call syntax. Call run() with a set of key=>value pairs. The two implemented keys are command (an array reference containing the command to run) and allowed (an array reference of exit values that are allowed without causing run() to return false or throw an exception.)

Poissonrun runs a given command statistically once every T seconds. The program can be run at any given time, but on average, it is every T seconds.
The random process is based on the poisson distribution.
Installation:
./configure
make
make install
Enhancements:
- This release adds new methods for specifying probabilities and time intervals, improves documentation, and adds a feature for having multiple commands in a running state simultaneously.

Chungles is a file-sharing program for local networks that runs on any platform.

More, its a file-sharing program that utilizes ZeroConf (JmDNS libraries) for computer detection and shares files easily about platforms with simple drag ndrop.

The GUI is done in SWT (allowing native graphics) and the program is written in Java.

This is a cpu throughput benchmark originally devised and used by Martin J. Bligh. It is designed to compare kernels on the same machine, or to compare hardware. To compare hardware you need to be running the same architecture machines (eg i386) and run kernbench on the same kernel source tree.
kernbench runs a kernel at various numbers of concurrent jobs: 1/2 number of cpus, optimal (default is 4xnumber of cpus) and maximal job count. Optionally it can also run single threaded. It then prints out a number of useful statistics for the average of each group of runs.
You need at least 2Gb of ram for this to be a true throughput benchmark or else you will get swapstorms.
Ideally it should be run in single user mode on a non-journalled filesystem. To compare results it should always be run in the same kernel tree.
Using:
You need a kernel tree (any will do) and the applications time and awk
installed. time is different to the builtin time used by BASH and has more
features desired for this benchmark.
Simply cd into the kernel tree directory and type
/path/to/kernbench
Options:
kernbench [-n runs] [-o jobs] [-s] [-H] [-O] [-M] [-h] [-v]
n : number of times to perform benchmark (default 5)
o : number of jobs for optimal run (default 4 * cpu)
s : perform single threaded runs (default dont)
H : dont perform half load runs (default do)
O : dont perform optimal load runs (default do)
M : dont perform maximal load runs (default do)
f : fast run
h : print this help
v : print version number
Enhancements:
- Incorrect counting of CPUs was fixed.
- The -j option was changed to at least 4GB ram.