Free ultra 90 software for linux

FCE Ultra is a NES (Nintendo Entertainment System) and Famicom (Family Computer) emulator for a variety of different platforms, based on Beros FCE. Game compatibility is very high, provided you provide non-corrupt ROM/disk images.
It has been tested (and runs) under DOS, Linux SVGAlib, Linux X, Mac OS X, and MS Windows. A native GUI is provided for the MS Windows port, and the other ports use a command-line based interface. The SDL port should run on any modern UNIX-like operating system(such as FreeBSD) with no code changes.
Enhancements:
- Latest code found on the net.

GNOME FCE Ultra (also known as gfceu) is an interface for the popular Nintendo Emulator, FCE Ultra. GNOME FCE Ultra is designed for the GNOME desktop, and allows the user to easily play NES ROM images.
Main features:
- Network play
- Custom input configuration
- Fullscreen support
- Full sound support
- High compatibility and accurate emulation

Qtel stands for the "QT EchoLink" client. It is only a EchoLink client application. There is no "sysop mode". If it is a link you want to run, have a look at the SvxLink (http://svxlink.sourceforge.net) server application.

EchoLink is an amateur radio invention (well actually it is just a modified verison of IP telephony) to link radio transcievers together over the Internet. You must have an amateur radio license to use it.

The original EchoLink software can be found at http://www.echolink.org/. However, this software only supports the Windows operating system and it is closed source. SvxLink is released under the GPL license. Qtel is only a EchoLink client program.

DataDraw is an ultra-fast persistent database for high performance programs written in C. The DataDraw project is so fast that many programs keep all their data in a DataDraw database, even while being manipulated in inner loops of compute intensive applications.

Unlike slow SQL databases, DataDraw databases are compiled, and directly link into your C programs. DataDraw databases are resident in memory, making data manipulation even faster than if they were stored in native C data structures (really).
DataDraw databases can be persistent.

Modifications to persistent data are written to disk as they are made, which of course dramatically slows write times. However, DataDraw databases can also be volatile. Volatile databases exist only in memory, and only for the duration that your program needs it. Volatile databases can be directly manipulated faster than C structures, since data is better organized in memory to optimize cache performance.

DataDraw supports modular design. An application can have one or more common persistent databases, and multiple volatile databases to support various tools data structures. Classes in a tools database can extend classes in the common database.
DataDraw is also 64-bit optimized, allowing programs to run much faster and in less memory than standard C programs using 64-bit pointers. This is because DataDraw databases supports over 4 billion objects of a given class with 32-bit object references.

DataDraw is released under the GNU Library General Public License, Version 2. It costs you nothing to use, and does not restrict your application in any way. Only the DataDraw program itself is covered by the license.

When to use DataDraw vs MySQL and PHP

LAMP is a very powerful combination for creating web applications: Linux, Apache, MySQL, and PHP. Apache provides an incredibly powerful framework built around a world-class web server. PHP provides a powerful language for developing web applications rapidly. MySQL provides a way for these web applications to manage data. DataDraw is not meant to replace any of this.

However, Apache is bloated, PHP is a slow interpreted language, and MySQL interprets ASCII commands that it reads through sockets that communicate with PHP. All this slows the system down 100-1000X, relative to plain old C code. Most applications dont care: if Im just trying to sell stuff over the Internet, being able to process even one transaction per second is probably fine.

DataDraw is for demanding applications for which LAMP is too slow and/or bloated. While running, a DataDraw application owns the database, and does not share it with others. That makes it well suited for implementing some tasks, and not others. For example, it is well suited for building SQL servers, or BitTorrent trackers, and embedded servers, but not well suited for Apache modules. In these cases, consider embedding both DataDraw, and a free, fast, tiny HTML server, such as the MiniWeb HTTP server, directly in your application. This will allow you to serve many times more requests per second, in far less memory..

Installation:

DataDraw3.0 is under heavy development, so it is wise to download and compile it directly from source. Use subversion like this:

$ svn co https://svn.sourceforge.net/svnroot/datadraw/trunk datadraw

Then, just switch to the datadraw directory, and type:

$ makemake
$make

This should create a datadraw executable. To figure out how to use it, read the manual, found in "manual.odt".

sverb is a simple order 15 CFDN reverb.
It was created under GNU/Linux. It may work on a lot of systems with OSS sound support.
It is in the public domain. Maybe some code inside it is based on patented stuff, I dont know. Check it if you want to use it in commercial applications.
Any improvement is very welcome.
Installation:
You need gtk+ 2.0. Audio is based on OSS.
Edit the Makefile to set or unset the ASM support. If you dont have an intel IA32 computer, you will need to unset it.
Then do a make.
Move the sverb binary file where you want, it does not require any other file.
Usage:
Launch the program. It has documentation. It is of course possible to extract the algorithm to use it in other programs. Just read the code, its all explained there.
Version restrictions:
- The early reflections are not modeled.
- Some low-pass filters could be added before/after the reverb stage, to improve naturalness.
Enhancements:
- Some presets were added, found with generate.c.
- Some minor fixing in the code also.
- It begins to be something!

Event::RPC is a event based transparent Client/Server RPC framework.

SYNOPSIS

#-- Server Code
use Event::RPC::Server;
use My::TestModule;
my $server = Event::RPC::Server->new (
port => 5555,
classes => { "My::TestModule" => { ... } },
);
$server->start;

----------------------------------------------------------

#-- Client Code
use Event::RPC::Client;
my $client = Event::RPC::Client->new (
server => "localhost",
port => 5555,
);
$client->connect;

#-- Call methods of My::TestModule on the server
my $obj = My::TestModule->new ( foo => "bar" );
my $foo = $obj->get_foo;

ABSTRACT

Event::RPC supports you in developing Event based networking client/server applications with transparent object/method access from the client to the server. Network communication is optionally encrypted using IO::Socket::SSL. Several event loop managers are supported due to an extensible API. Currently Event and Glib are implemented.

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.

Sussen is a tool that checks for vulnerabilities and configuration issues on computer systems. It is based on the Open Vulnerability and Assessment Language.