Free frees 1 software for linux

Luxor is a free, open-source XML UI Language (XUL) toolkit in released under the GNU General Public License (GPL) that lets you build UIs using XML and includes an ultra-light weight, multi-threaded web server, a portal engine, a template engine (Velocity), a scripting interpreter (Python) and more.

XUL stands for XML UI Language and was pioneered by Mozilla. XUL is superior to API-based UI toolkits such as Swing or WinForms because it clearly separates the user interface into four parts:

- content (structure and description of UI elements),
- appearance (look & feel, skin, themes),
- behavior (scripting) and
- locale (localization information for internationalization)

Content is best described in XUL as the following short example illustrates.

XUL makes UI building easier because it is far simpler than hard-wiring it in Java. XUL also frees you from the Swing toolkit lock-in because you can create a new rendering engine using a different UI toolkit such as KDE, Gnome, or WinForms.

Worminator 3 is akin to many Apogee Software and ID Software classic action games such as Duke Nukem and Commander Keen.
In Worminator game, you play as The Worminator (or as several other optional characters) and fight your way through many levels of madness and mayhem.
It features nine unique weapons, visible character damage, multiple supported resolutions, full screen scrolling, sound and music, and more.
Original Worminator story...
The year is 2028, 14 years after the start of the deadliest war in the history of worm kind. Much has changed... In the year 2012; a brilliant American scientist discovered how to make W.O.R.M. (Wormborg Operated Remote Missile) Weaponry, and to work them, the "WormBorgs" cyborg fighting machines.
These so called "WormBorgs" were the elite fighting force and the pride of the United Worms of America. Their life-like roles soon became far too life-like. They thought on their own, and acted on their own whims, under their own leader "DirtNet." No one exactly knows who or what "DirtNet" is, but it soon began to take over.
First, it launched the W.O.R.M.s at the Woroviet Union, in the hopes that they would retaliate and initiate a war between the Woroviet Union and the UWA. However, "DirtNet" obviously had a few bugs to work out, and the W.S.S.R was obliterated into millions of radioactive hunks of mud and dirt. Despite the fact that no one liked Wormunism anyway, all of Wormurope retaliated against the UWA.
Soon, the world was turned into a nuclear wasteland. Nuke drops became daily ordeals, and the giant bombs turning whole forests into matchsticks was to be expected. As if the sewers werent loaded with enough mutated alligators as it was, the hunks of radioactive material combined with the primordial soup of the sewers are said to have created blobs of sewage ooze, powerful enough that they fed off the mutated alligators for lunch.
After what was left of Wormurope had realized what tricks had been played on them by "DirtNet," they began to rally and fight back. For 8 years, the WormBorgs dominated the lands, crushing the rebels... until one faithful day, when the now famous rebel hero emerged. It was Wrom Conner.
No longer acting as individual factions, countries or nations, the rebels struck quickly and fiercely under Wroms command, using tactics that even the powerful W-1000s processors could not predict. The tide of the war had turned.
Over the next 5 years, the rebels devastated the WormBorgs. Using guerilla tactics and reprogrammed WormBorgs to fight for them, the rebels were a resourceful army indeed. Now, in desperation, "DirtNet" has just brought its proto-type WormBorg online, equipped with the latest in armor and weaponry, in one last attempt to regain control...
Main features:
- Fast, fluid scrolling
- 12 unique weapons, and many types of ammo
- Lots of gibs and shrapnel (all cartoonish, though)
- Visible character damage (as you get hurt, the Worminator actually becomes bloody)
- Visible weapons (every weapon actually appears differently on the Worminator. Most platform games have a single weapon graphic that shoots every type of projectile)
- Over 12 fully animated enemies
- Comes with over 16 levels, and a level editor is included so you can make your own
- Keycards, doors, special items, switches, lever, extending bridges, floating platforms, and more!
- Earthquakes rip the ground apart, while snow and rain fall around you
- Great MIDI tunes by Garret Thomson (garret_t@sympatico.ca, www.sirsonic.com)
- Many sound effects (All from Internet sites such as Sound America and Meanrabbit. Let me know if there are any copyright problems, and I will deal with them immediately)
- Parallax scrolling, plus four data layers in every map. This makes the engine very flexible
- Game includes a campaign game with special scripted events, as well as an option to load custom maps
- Stereo sound effects (where available)
- Limited skins support; you can play as different characters!
- Built using Allegro + DJGPP. Source code may be made available if the demand is there
- If you wish to use the Worminator engine, contact me and we will discuss it (I would never charge any money for it, so if your interested, drop me an email. You have nothing to loose)
- Totally Freeware!
Enhancements:
- made worminator compile and run on Linux (Unix)
- made worminator yield the cpu when its idle
- save settings in textfile format under $HOME/.worm3.cfg instead of as binary blob in cwd
- save / load game to / from $HOME/.worm3.sav
- load datafile from DATADIR as defined during compilation instead of from cwd
- speedup: dont redraw borders and statuspanel unless nescesarry
- check all file accesses and give an error and continue when possible instead of just segfaulting
- fix a crash when changing audio options after loading a savegame of a custom-level or the tutorial
- fix a crash (unix only?) when changing video options and one similar on exit
- fix crash on exit caused by a few double frees on exit
- dont ask for confirmation on load/play_demo/exit when their is no game in progress
- show a message when trying to save when no game is in progress, instead of just silenty ignoring the request
- when clicking on another submenu when in one not only close the current one, but also open the new one
- fix map / savegame / demo read/write routines so that they work on Big Endian archs like PPC too

libxode is an XML library which wraps expat. In C even. It offers a very flexable DOM, and uses Memory Pools (which can also be created/used from this library).
libxode also features handling of XML streams and some convenience functions for string handling using memory pools.
Main features:
XML Parsing
- XStreams for parsing XML in a stream
- Xodes a highly flexible DOM
- On Demand child parsing (well, soon)
Memory Pools
- Organize related memory into one structure
- Save mallocs and frees with heap pre-allocation
Spools
- Simple handling of strings
- Simple concatencation
- Utilizes Pools for simple memory handling

FreeS/WAN is an implementation of IPSEC & IKE for Linux. IPSEC is Internet Protocol SECurity. It uses strong cryptography to provide both authentication and encryption services. Authentication ensures that packets are from the right sender and have not been altered in transit. Encryption prevents unauthorised reading of packet contents. These services allow you to build secure tunnels through untrusted networks.

Two protocols are used

ESP (Encapsulating Security Payload) provides encryption plus authentication
IKE (Internet Key Exchange) negotiates connection parameters, including keys, for ESP

Freeswan implementation has three main parts:

KLIPS (kernel IPsec) implements ESP, and packet handling within the kernel
Pluto (an IKE daemon) implements IKE, negotiating connections with other systems
various scripts provide an adminstrators interface to the machinery.

Because IPsec operates at the network layer, it is remarkably flexible and can be used to secure nearly any type of Internet traffic. Two applications, however, are extremely widespread:

a Virtual Private Network, or VPN, allows multiple sites to communicate securely over an insecure Internet by encrypting all communication between the sites.
"Road Warriors" connect to the office from home, or perhaps from a hotel somewhere

There is enough opportunity in these applications that vendors are flocking to them. IPsec is being built into routers, into firewall products, and into major operating systems, primarily to support these applications. See our list of implementations for details.

We support both of those applications, and various less common IPsec applications as well, but we also add one of our own:

opportunistic encryption, the ability to set up FreeS/WAN gateways so that any two of them can encrypt to each other, and will do so whenever packets pass between them.

This is an extension we are adding to the protocols. FreeS/WAN is the first prototype implementation, though we hope other IPsec implementations will adopt the technique once we demonstrate it. See project goals below for why we think this is important.

A somewhat more detailed description of each of these applications is below. Our quickstart section will show you how to build each of them.

tsrip is an audio CD ripping and encoding solution. tsrip project supports free codecs, gets album information from the musicbrainz database, and has a simple-to-use command-line user interface.

Free Simulated Radar Client project is a framework for radar clients for virtual air traffic control networks.

Free Simulated Radar Client is a framework for radar clients for virtual air traffic control networks (e.g., VATSIM and IVAO). Currently work is occuring on a radar client (an ASRC clone), a flight strip display, and a 3D tower view.

The framework analyses the data provided by servers of these networks and provides interfaces for radar clients (or other applications) to access this data.

jsTemplate is a small JavaScript library that allows you to create templates like PHP and ASP with JavaScript.

The project can fetch templates using AJAX and execute them into the browser. The code is an evolution from the StickyShare.com project.

jsTemplate is a very small library (just 4k minified) written in javascript that allows you
to write template file similar to PHP or ASP but using JavaScript.

The main advantage of this solution is the fact that the clients browser perform all
the operations and it frees your server. Your web server has only to send a static file
and it has more resources to do really important task like data access.

We developed this as an evolution from the code of StickyShare (www.stickyshare.com) and we plan to use it for future releases.

Tie::ListKeyedHash is a system allowing the use of anonymous arrays as keys to a hash.

SYNOPSIS

use Tie::ListKeyedHash;

[$X =] tie %hash, Tie::ListKeyedHash;


my $live_key = [key,items,live];
$hash{$live_key} = Hello!;

$hash{[key,trees,grow]} = Goodbye!;

print $hash{[key,items,live]},"n";
delete $hash{$live_key};

my @list = keys %{$hash{[key]}};
print "@listn";

untie %hash ;

Alternatively keys are accessible as:

$hash{key,items,live} = Hello!;

(a bare list/array for the key rather than using an anon list/array reference).

But that slows down the accesses by around 10% and cannot be used for keys that conflict with the value of the $; special variable.

Also usable via the object interface methods put, get,exists,delete,clear. The object interface is about 2x as fast as the tied interface.

Tie::ListKeyedHash ties a hash so that you can use a reference to an array as the key of the hash. It otherwise behaves exactly like a normal hash (including all caveats about trying to use a key as both a hash reference and a scalar value).

This frees you from needing to hardwire hash references in code or having to write tree traversal code to reach arbitrary points in a hash tree.
Example:
########################

#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

use Tie::ListKeyedHash;

my %example;
tie (%example, Tie::ListKeyedHash);

%example = (
a => {
b0 => {
c => value of c,
d => value of d,
e => {
f => value of f,
},
},
b1 => {
g => value of g,
},
},
h => r,
);

my $b_key = [a,b0];

my $d_key = [@$b_key,d];
my $d = $example{$d_key};
print "d = $dn";

my $e_key = [@$b_key, e];
my $e = $example{$e_key};
print e = . Dumper ($e);

my $f_key = [@$b_key, e,f];
my $f = $example{$f_key};
print "f = $fn";

my $h_key = [h];
my $h = $example{$h_key};
print "h = $hn";

########################

The virtues of this particular way of accessing hash-of-hashes (HoH) vs bare hardwired derefererences or tree crawling are as follows:

1) As the number of levels in a HoH increases, the tied object asymptotically approaches the speed of hardwired hash dereferencing without the loss of flexibility penalty of having to hardwire the keys into code in advance.
This gives an important property that it gets faster the deeper a HoH becomes as compared with the speed of software driven tree traveral.
So you can build and access arbitrarily structured HoH and still access deeply buried elements in the tree quickly.
2) The format was designed to use memory efficiently. It takes only a few hundred extra bytes over the size of an untied HoH in memory or when serialized (via Data::Dumper or Storable for example) regardless of how deep the hash is.
3) A reference to an existing HoH can be passed into Tie::ListKeyedHash->new and all of the OO key lists access methods will "just work".

Example:

use Tie::ListKeyedHash;

my %hash = ( a => { b => c } );
my $obj = Tie::ListKeyedHash->new(%hash);

my $b_value = $obj->get([a,b]);