Dirty Water project is a custom MUD server.

Dirty Water is an original MUD server/engine written in OCaml.

It is designed to be much more advanced and realistic and to encourage role playing more than Diku-style MUDs.

We are using a higher level language which we feel will yield a code-base that is significantly easier to modify, maintain and understand.

We felt that OCaml would make a good choice for this language, though we have since decided Scheme would be a better choice.

All of our code is licensed under the GNU GPL.

Whats New in This Release:

· can pick up items
· can view inventory
· you can specify 1st, 2nd, etc when refering to items
· cant pick up buildings or yourself
· dont see yourself in room descriptions

Bemused is a system which allows you to control your music collection from your phone, using Bluetooth. You will need to have a Series 60 or UIQ phone (e.g. Nokia 7650/3650, or Sony Ericsson P800/P900), and a PC with a Bluetooth adapter.

Here are some key features of "WaterKills":

· Browse your music collection on your phone
· Play files in any format supported by Winamp - including MP3s, CDs, MIDIs, etc.
· Control Winamp versions 2, 3 and 5, Windows Media Player and PowerPoint Viewer
· Pause, stop, rewind, fast-forward etc.
· Add songs to the playlist and use shuffle and repeat
· Browse and select songs in your playlist
· Download songs to your phone (supported formats: WAV and MIDI; plus MP3 for UIQ)
· Customise the look of the system with skins

Whats New in This Release:

· Series 60: Added new version of German localisation by Ozan Sambur
· Integrated Joachim von Carons fix for a potential PowerPoint crash
· Added ability to get current volume on startup (Winamp 2 or 5 only)
· Fixed bug where song title would be wrong after a playlist repeating
· Fixed bug with getting current song time with Winamp 5
· Fixed crash when pressing Play when using PowerPoint with no presentation loaded
· Improved handling of comms errors in the Bemused server

Lingua::Phonology::Features is a module to handle a set of hierarchical features.

SYNOPSIS

use Lingua::Phonology;

my $phono = new Lingua::Phonology;
my $features = $phono->features;

# Add features programmatically
$features->add_feature(
Node => { type => privative, children => [Scalar, Binary, Privative] },
Scalar => { type => scalar },
Binary => { type => binary },
Privative => { type => privative }
);

# Drop features
$features->drop_feature(Privative);

# Load feature definitions from a file
$features->loadfile(phono.xml);

# Load default features
$features->loadfile;

Lingua::Phonology::Features allows you to create a hierarchy of features of various types, and includes methods for adding and deleting features and changing the relationships between them.

By "heirarchical features" we mean that some features dominate some other features, as in a tree. By having heirarchical features, it becomes possible to set multiple features at once by assigning to a node, and to indicate conceptually related features that are combined under the same node. This module, however, does not instantiate values of features, but only establishes the relationships between features.

Lingua::Phonology::Features recognizes multiple types of features. Features may be privative (which means that their legal values are either true or undef), binary (which means they may be true, false, or undef), or scalar (which means that their legal value may be anything). You can freely mix different kinds of features into the same set of features.

Finally, while this module provides a full set of methods to add and delete features programmatically, it also provides the option of reading feature definitions from a file. This is usually faster and more convenient. The method to do this is "loadfile". Lingua::Phonology::Features also comes with an extensive default feature set.

Deep-Water Linux is a half minimalist software distribution using the linux kernel released under the terms of the gnu gpl license v2.

Originaly i designed it for myself to make my work a bit easyer - it was a few years ago when there were not so many live distributions that fit my needs - i needed something more than "minimal" but not something that would need more than 2-3 minutes to load requireing hardware, that i couldnt afford.

So i designed a small system for myself that i could use whenever i broke my "harddisk" distro so much, that it was impossible to repair the system from inside of it. I started using the system as a sort of a rescue system and i installed it on my computer as a sort of a neighbour to other systems that i have used.

Then i thought other people might find it interesting, if not as a whole, than atleast a part of it, or maybe they might like to use it for some "rescue job". I was messing arround with xlib and tcl/tk, so i added some programs to ease a users life - like a panel, icons, file-manager. You see, i thought it is stupid to just copy someones work and then re-distribute it in my name - i hate the kind of distros where the "developers" just change the background of some well known distro and then give it a new name.

In my distro you wont find so many tools, it evean might not work good, it evean can make you angry "make you laugh, or cry", but atleast i can say, that many things in this system is my work - i programmed deep-panel/ deep-view/ deep-icons/ made a new hackedbox"a hack of blackbox"/designed the startup and many other things.

There are 2 version-types of the distro - the first copying the whole system in the memmory and the second copying only a part of itself - the first is for people with older hardware with little memmory and the second for boxes with memmory atleast 128MB. I know that there are many systems out there that are better and im not saying that its good to use this distro on an everyday basis, but if you find some inspiration in it, or if you use it as a rescue system, or want to use deep-view to browse/edit some files or to display image galleries and your "real" system is broke, if you find any use of it than im happy enough.

Gimp::Feature is a Perl module that can check for specific features to be present before registering the script.

SYNOPSIS

use Gimp::Feature;
or
use Gimp::Feature qw(feature1 feature2 ...);

This module can be used to check for specific features to be present. This can be used to deny running the script when neccessary features are not present. While some features can be checked for at any time, the Gimp::Fu module offers a nicer way to check for them.

gtk

checks for the presence of the gtk interface module.

gtk-1.1, gtk-1.2

checks for the presence of gtk-1.1 (1.2) or higher.

perl-5.005

checks for perl version 5.005 or higher.

pdl

checks for the presence of a suitable version of PDL (>=1.9906).

gnome

checks for the presence of the Gnome-Perl module.

gtkxmhtl

checks for the presence of the Gtk::XmHTML module.

unix

checks wether the script runs on a unix-like operating system. At the moment, this is every system except windows, macos, os2 and vms.

persistency

checks wether the Gimp::Data module (Gimp::Data) can handle complex persistent data structures, i.e. perl references in addition to plain strings.

The following features can only be checked after Gimp-main> has been called (usually found in the form exit main). See Gimp::Fu on how to check for these.
gimp-1.1, gimp-1.2

checks for the presense of gimp in at least version 1.1 (1.2).

FUNCTIONS

present(feature)

Checks for the presense of the single feature given as the argument. Returns true if the feature is present, false otherwise.

need(feature,[function-name])

Require a specific feature. If the required feature is not present the program will exit gracefully, logging an appropriate message. You can optionally supply a function name to further specify the place where this feature was missing.

This is the function used when importing symbols from the module.

missing(feature-description,[function-name])

Indicates that a generic feature (described by the first argument) is missing. A function name can further be specified. This function will log the given message and exit gracefully.

describe(feature)

Returns a string describing the given feature in more detail, or undef if there is no description for this feature.

list()

Returns a list of features that can be checked for. This list might not be complete.

Bio::DB::GFF::Feature is a relative segment identified by a feature type.

Bio::DB::GFF::Feature is a stretch of sequence that corresponding to a single annotation in a GFF database. It inherits from Bio::DB::GFF::RelSegment, and so has all the support for relative addressing of this class and its ancestors. It also inherits from Bio::SeqFeatureI and so has the familiar start(), stop(), primary_tag() and location() methods (it implements Bio::LocationI too, if needed).

Bio::DB::GFF::Feature adds new methods to retrieve the annotations type, group, and other GFF attributes. Annotation types are represented by Bio::DB::GFF::Typename objects, a simple class that has two methods called method() and source(). These correspond to the method and source fields of a GFF file.

Annotation groups serve the dual purpose of giving the annotation a human-readable name, and providing higher-order groupings of subfeatures into features. The groups returned by this module are objects of the Bio::DB::GFF::Featname class.

Bio::DB::GFF::Feature inherits from and implements the abstract methods of Bio::SeqFeatureI, allowing it to interoperate with other Bioperl modules.
Generally, you will not create or manipulate Bio::DB::GFF::Feature objects directly, but use those that are returned by the Bio::DB::GFF::RelSegment->features() method.
Important note about start() vs end()

If features are derived from segments that use relative addressing (which is the default), then start() will be less than end() if the feature is on the opposite strand from the reference sequence. This breaks Bio::SeqI compliance, but is necessary to avoid having the real genomic locations designated by start() and end() swap places when changing reference points.

To avoid this behavior, call $segment->absolute(1) before fetching features from it. This will force everything into absolute coordinates.

For example:

my $segment = $db->segment(CHROMOSOME_I);
$segment->absolute(1);
my @features = $segment->features(transcript);

Bio::Graphics::Feature is a simple feature object for use with Bio::Graphics::Panel.

SYNOPSIS

use Bio::Graphics::Feature;

# create a simple feature with no internal structure
$f = Bio::Graphics::Feature->new(-start => 1000,
-stop => 2000,
-type => transcript,
-name => alpha-1 antitrypsin,
-desc => an enzyme inhibitor,
);

# create a feature composed of multiple segments, all of type "similarity"
$f = Bio::Graphics::Feature->new(-segments => [[1000,1100],[1500,1550],[1800,2000]],
-name => ABC-3,
-type => gapped_alignment,
-subtype => similarity);

# build up a gene exon by exon
$e1 = Bio::Graphics::Feature->new(-start=>1,-stop=>100,-type=>exon);
$e2 = Bio::Graphics::Feature->new(-start=>150,-stop=>200,-type=>exon);
$e3 = Bio::Graphics::Feature->new(-start=>300,-stop=>500,-type=>exon);
$f = Bio::Graphics::Feature->new(-segments=>[$e1,$e2,$e3],-type=>gene);

This is a simple Bio::SeqFeatureI-compliant object that is compatible with Bio::Graphics::Panel. With it you can create lightweight feature objects for drawing.

BubbleMon is a system monitoring dockapp, visually based on the GNOME "BubbleMon" applet. Basically, it displays CPU and memory load as bubbles in a jar of water. But thats where similarity ends.

New bubblemon-dockapp features translucent CPU load meter (for accurate CPU load measurement), yellow duck swimming back and forth on the water surface (just for fun), and fading load average and memory usage screens.

Either of the info screens can be locked to stay on top of water/duck/cpu screen, so that you can see both statistics at once. Pretty nifty toy for your desktop. Supports Linux, FreeBSD, OpenBSD, and Solaris 2.6, 7 and 8. Code has been thoroughly optimized since version 1.0, and even with all the features compiled in, BubbleMon still uses very little CPU time.

Load Average screen locked at about 20% looks particularly sexy (pictured at right). All the extra "bloated" features can be compiled out or disabled on command-line, if you prefer original "BubbleMon" look.

Ember is a 3d client for the WorldForge project. It uses the Ogre 3d graphics library for presentation and CEGUI for its GUI system.

The client can model a full 3d world with dynamic terrain generation. It has an easy to use GUI system with widgets for server browsing, login, and character selection, and context menus for in game interaction.

WorldForge::Ember has support for experimental graphical features such as dynamically generated trees, realistic water, and ground cover.

Here are some key features of "WorldForge Ember":

· Full 3d world with dynamic terrain generation
· Easy to use GUI system
· Context menus for in game interaction
· Support for experimental graphical features such as dynamically generated trees, realistic water and ground cover

KGLWaterSaver is a screensaver that looks like a water-talbe.

Here are some key features of "KGLWaterSaver":

· Choose between Images or the current Desktop to "sink under water"
· Various effects: Whirl, Bubble, Rain

Installation:

Download, compile and install.

Go to the Control Panel and choose KGLWaterSaver, set it up to use your favourite Image or Desktop and fit the performance of your computer.

(Takes 10% CPU-Time at my Duron 700 / GeForce FX 5700 at: water_res of 128x128, 24 WaterCalcs, 64ms Delay Realtime) (config dialog will probably [hopefully be more intuitive in following versions)

Bulk Meter Flow and Operations provides a Web-based application to manage water meter readings.

xdesktopwaves is a cellular automata which sets the background of an X11 desktop as if it were under water.

Window and mouse movements cause ripples on the desktop like ships on the sea. You can also simulate rain or a storm stirring up the water.

Alien Arena 2006 is the ultimate freeware deathmatch game!

Included are 25 total levels, 9 detailed characters, 8 weapons, 2 vehicles, 5 gameplay modes(DM, TDM, CTF, All Out Assault, Deathball), and much more!

New for Alien Arena 2006 are five mutators(instagib, regeneration, vampire, rocket arena, and low grav), and Deathball, a mode in which you get points by capturing a ball and firing in into a goal.

Eight new levels have been added, as well as alternate firing modes for several of the weapons. The game now runs on version 4.03 of the CRX engine, based on the id Software GPL source codes, and adding nextgen features such as reflective water, shaders, light bloom, improved lighting, and much more, while optimizations allow it to still run extremely fast even on modest systems.

The game now features colored names, an improved console, and an enhanced in-game server browser.

Also available is the "Nightmare Bots" patch, which adds a fourth skill level to the in-game bots, which will challenge even the best players.

Gerris project is an Open Source Free Software library for the solution of the partial differential equations describing fluid flow.

Gerris is supported by NIWA (National Institute of Water and Atmospheric research) and by the Marsden Fund of the Royal Society of New Zealand.

The code is written entirely in C and uses both the GLib Library and the GTS Library for geometrical functions and object-oriented programming.

Here are some key features of "The Gerris Flow Solver":

· The same code base is compiled with 2D and 3D support.
· Quadtree-based (Octree in 3D) spatial discretisation with automatic and dynamic local refinement.
· Multigrid Poisson solver.
· Second-order Godunov type advection scheme.
· Solves the time-dependent incompressible variable-density Euler, Stokes or Navier-Stokes equations or the 2D shallow-water and 3D hydrostatic oceanic equations.
· Support for complex solid boundaries (automatic locally-refined mesh generation).
· Semi-implicit multigrid diffusion solver with support for complex boundaries and associated boundary conditions in 2D and 3D.
· Semi-implicit multigrid barotropic solver for the oceanic equations.
· Adaptive mesh refinement: the resolution is adapted dynamically to the features of the flow.
· Flexible and powerful specifications of parameters.
· Flexible object-oriented custom specification of initial and boundary conditions, source terms, outputs etc...
· Portable parallel support using the MPI library.
· Volume of Fluid advection scheme for interfacial flows.

Whats New in This Release:

· Bugfixes and significant speedups in the multilevel Poisson solver.
· Support for variable mesh resolution along solid boundaries.
· Improvements have been made to the robustness of very complex solid boundaries.
· Adaptive refinement of VOF-advected tracers has been added, as well as a preliminary implementation of CSF surface tension using Renardy El Ab.
· "proper discretisation".
· Solid boundaries can be refined according to the local curvature.
· Implicit Coriolis terms work with the Navier-Stokes solver.
· There is support for "thin" 3D domains.

Windstille project is a classic jump and shoot action game.

Windstille is an old-school 2D site-scrolling shootem up game, similar to Turrican or Metroid with some influence from Another World and Flashback.

In Windstille the player will be placed in a foreign alien world and has to find its way back into safety. Special focus will be on getting the foreign world and the players character itself believable.

Exploration will be more needed than plain shoot action, even so the players-character will be equipped with a multifunctional war-suit, so he will be far from defenseless.

The game will have slow placed explore and seak sequences as well as more rough section that will feature fast shoot and jump action. The game world should be presented in a consistent state, enemies once destroyed should not respawn automatically.

The player is free to go forward and backward in the world as long as the level design allows it.

Whats New in This Release:

· 3D sprites, giving fluent animation and the ability to zoom in without pixelation in the characters
· multi color light effects for added athmospheric effect as well as new gameplay posibilities
· flexible particle systems for fire, water smoke and such
· dynamic 2D water
· Squirrel based scripting
· console to enter script commands
· simple dialog system
· cutscene support
· menu system for easy access to all the parts and features of the game