Free system that uses software for linux

Ulteo project is the easiest system to use on computers. Ulteo is a new concept of an easy-to-use open-source operating system which could change the way we all use computers.

As a result, users have to perform tasks that should be reserved to computer specialists, while we think that users should just spend time using the applications they need. Ulteo tries to provide answers to these issues.

The first answer we have is to consider the OS + applications as a whole system that we could call an "Application System". This system should:

1- always provide the most up to date stable features and self-upgrade automatically
2- require no, or very little, administration by the user
3- open users horizon to potentially every application which exists, the simple way

For this release of Ulteo Sirius Alpha1, we have focused on the first point. This means that after the first installation, Ulteo will try to check for any new versions available if a network connection is available, and self-upgrade by using an incremental upgrade mechanism.

What this means is that for the next alpha release version, no installation will be needed. Simply rebooting the system will be enough to get the new features and bug fixes.

MPEG Menu System Version2 is a menu system for easy movie, audio, and image playback. It supports many common file formats, including MP3, OGG, DivX, XviD, VCD, SVCD, DVD, JPEG, PNG, and GIF.
MPEG Menu System 2 is controlled using a remote control, USB device, or keyboard. It supports DXR3, DVB, X11, SDL, and framebuffer output.
Enhancements:
- Many small bugfixes and new "play now" functionality.

AJAX Image Dump System or AIDS for short, is a image dump system written in PHP and Javascript using MYSQL databases, with AJAX functionality using the jquery library and the MOD_REWRITE Apache module to shorten down URL-addresses. The system also uses the XTemplate.
Enhancements:
- Fixed the bug causing the second image uploaded to fail, and send the user to the upload.php page.
- See https://sourceforge.net/tracker/index.php?func=detail&aid=1735653&group_id=198562&atid=965971 for more info regarding this bug.
- Got more of the system onto the xtemplatephp-system and added support for multiple languages, translation will begin shortly.
- Better support for adding other languages will come in one of the next releases. (See langNO.php for the current running language).
- Changed the link for the pictures after a uploading to point to the right page (removed .jpg at the end of the link).

Incredible Hosting System is a tool that allows you to administrate a hosting system using a Web browser.
The aim is to support administrators and users. Incredible Hosting System currently includes support for Virtual Qmail.
IHS will be a platform for implementing and integrating mail or hosting systems in different environments - small or medium companies looking for tools for managing system accounts, hosting companies offering services based on this system.
System is complex, requires integration of many other applications, for example: WWW server, mail transfer agent, FTP server, database. Also it should be possible to integrate system with other applications that are specific to companys environment.
Aside integration of existing application platform must be built that will allow to manage everything is a manner undependent from tools that are used in background. It should be a centralized and consistent environment. Also API for developers shoule be generic that changes in tools doesnt require changes in code.
Incredible Hosting System will be based on following tools, technologies:
- Apache as WWW server;
- PostgreSQL as default database;
- ProFTPD as default database;
- qmail or Virtual Qmail as a MTA;
- CORBA as a service communication protocol;
- J2EE as an runtime environment;

My Own Building System (a.k.a. mobs) is a GPLd build system, lightweight and easy to use, with a limited application framework. My Own Building System project gets information from the end-user wanting to build your project and modifies the building process according to such information.

It provides the developer with some development helpers, including some makefile framework and an interface for the end-user (the 0 script). This building system supports the (more or less) automatic building of C, C++, Bison/Yacc, Flex/Lex, and Texinfo source files, and the creation of static and shared libraries and binaries.

It is not a GNU autoconf/automake clone, and although the command line of the 0 script certainly mimics the one of GNU configure it is only for the sake of end-users. Internally, and from the point of view of the developer, is very different.

The Plastic File System project is an LD_PRELOAD module for manipulating what the file system looks like for programs. This allows virtual file systems to exist in user space, without kernel hacks or modules.
PlasticFS includes the following file systems:
chroot
The chroot filter may be used to simulate the effects of the chroot(2) system call, in combination with other filters.
dos
The dos filter may be used to simulate an 8.3 DOS file system.
log
The log filter may be used to transparently log file system access, similar to the strace command.
shortname
The shortname filter may be used to simulate file systems with shorter filenames.
smartlink
The smartlink filter may be used to expand environment variables in symbolic links, using the usual $name notation.
upcase, downcase, titlecase and nocase
The upcase filter to make file names appear to be in upper-case when listed. File names are case- insensitive when being opened, etc. The downcase filetr is similar, except it converts to lower-case, titlecase capitalizes, and nocase is simply case insensitive without altering the filenames.
viewpath
The viewpath filter may be used to make a set of directory trees look like a single directory tree. (Also known as a union file system.) All modifications take place in the first directory in the list.
Aka: union and translucent
Note: Filters may be piped from one to the next, forming powerful combinations.
PlasticFS is currently dependent on the implementation of the GNU C Library. It is self configuring using a GNU Autoconf generated configure script.
Enhancements:
- Build problem fixed.

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]);