Free game system emulator software for linux

All System Info is a system info SuperKaramba theme. Simple english version...
It shows:
- System Info
- CPU usage
- Network Usage
- Memory Load
- HDD usage

Jagacy 3270 Emulator is a feature-rich 3270 terminal emulator. It supports SSL, TN3270E, and over thirty languages. The project does not contain the screen-scraping library, and is a cost effective solution for a stand-alone Java 3270 terminal emulator.
The emulator can be configured to help create screen-scraping applications. Developers can also develop their own custom terminal emulators (with automated logon and logoff). Jagacy 3270 screen-scraping is faster, easier to use, and more intuitive than HLLAPI. It excels in creating applications reliably and quickly.
Main features:
- 100% pure Java.
- Feature rich 3270 terminal emulator.
- SSL support.
- Extended TN3270 (TN3270E) support.
- 17 different terminal types (including 132 columns).
- Internationalization support. Over 30 different languages supported.
- Configurable using properties, if desired. No changes necessary when host name or screens change.
- Easily create a custom 3270 terminal emulator.
- Small footprint (less than 150K). Runs efficiently within the Eclipse and NetBeans IDEs.
- Can display the 3270 session in a window while an application is running.
- Includes a full-featured 3270 terminal emulator tailored to developing and debugging applications.
Enhancements:
- Add features/limitations/changes here

Online Cardgame System project is a client-server system for playing card games over the net.
OCS is a client-server cardgame system, similar to those found at Yahoo! Games and elsewhere. The server is portable and has been tested under Linux, Win32, and several unix systems. We currently have Win32 and Java clients available, and a Qt client for Linux is in development.
Games are implemented as plugin modules, so new games can be added without recompiling the server. In addition, the client is written to be unaware of the mechanics of gameplay, so it can theoretically play any games the server supports without having to know how to play them specifically.
We currently have Euchre and Spades implemented, with bot support for both games, meaning you dont need a full 4 people to play a game. We plan on implementing more games in the future.
On a side note, development of this project tends to wax and wane with our motivation and amount of schoolwork.
Enhancements:
- Massive restructure of code into more object orientated patterns
- Added daemon capability to server
- Got rid of checksumming in the protocol since TCP/IP does it internally
- Padded STRINGS in the protocol on DWORD boundaries
- Added support for loadable account managers
- Removed crypting of the password by ocsd (account managers may do it)
- Added ODBC (for windows) and mySQL (for unix) account managers (database connectivity!!)
- Modified packet classes to throw exceptions instead of returning true-false
- Created packet manager classes to queue client packets, reduces total send calls
- Implemented bots when there arent enough people to play games
- Added new command line processing capabilities as well as configuration file support
- Fixed bug that allowed a person to overwrite an account when creating that same account
- Win32 - Made server link with DLL runtime library to reduce executable size and ease DLL dependencies
- Updated messages to be sent in HTML since the main clients support it
- Created Java client which can be run as an application or as an applet
- After a client is booted from a game, they cannot join the game again until they receive an invitation
- Fixed libtidy bug which caused it to erroneously format HTML
- Euchre supports intelligent bots
- Spades supports moronic bots (the AI is horrible but allows for gameplay)
- Fixed Spades textual problem when a round was over.
- Fixed Spades score calculation that resulted in no loss of points
- Win32 client now supports HTML (IE4+ required)
- Win32 client can now join games by right-clicking on an empty game slot in the game view.
- Fixed major bug in Win32 client that would cause it to crash when sending private messages
- Win32 client can now use /msg to send private messages

Game Launcher project is a universal front end for emulators.
The main goal is to provide a user interface that is easy to use and attractive, yet does not look like a traditional user interface with windows and such.
Game Launcher should work with any emulator, but it has been known to work with MAME, Nesticle, RockNES, zSNES, snes9x, Callus, Stella, z26, and Versions are available for Unix, DOS, and Windows.
Main features:
- Very flexible. It should run with any command line emulator.
- Simple and easy to use interface.
- Plays music in the background (MP3s or an audio CD).
- Displays screenshots (PNG, PCX, BMP, and JPEG).
- Customizable font.
- Customizable screen resolution.
- Support for vertical (rotated) monitors.
- Slight menu animations.
- Support for PC joysticks.

Games::3D is a package containing an object system for (not only) 3D games.

SYNOPSIS

use Games::3D::World;

my $world = Games::3D::World->new();

$world->save_to_file( $filename );

my $loaded = Games::3D::world->load_from_file( $filename );

my $thing1 = $world->add ( Games::3D::Thingy->new( ... ) );
my $thing2 = $world->add ( Games::3D::Thingy->new( ... ) );

$world->link($thing1, $thing2);

Games::3D::World provides you with a container class that will contain every object in your game object system. This are primarily objects that have states, change these states and need to announce the states to other objects.

The Games::3D::World container also enables you to save and restore snapshots of your objects system.

Basic things that you object system contains are derived from a class called Games::3D::Thingy. These can represent physical objects (buttons, levers, doors, lights etc) as well as virtual objects (trigger, sensors, links, markers, sound sources etc).

You can link Thingys together, either directly or via Games::3D::Links. The links have some more features than direct linking, which are explained below.

This package also provides you with Games::3D::Sensor, a class for objects that sense state changes and act upon them. Or not, depending on the sensor. Sensors are primarily used to watch for certain conditions and then act when they are met. Examples are the death of an object, values that go below a certain threshold etc.

State changes are transported in the object system with signals.

The xterm program is the standard terminal emulator for the X Window System. xterm patch provides DEC VT102/VT220 and Tektronix 4014 compatible terminals for programs that cant use the window system directly.
If the underlying operating system supports terminal resizing capabilities (for example, the SIGWINCH signal in systems derived from 4.3bsd), xterm will use the facilities to notify programs running in the window whenever it is resized.
I decided to work on this in early 1995, to support ded and add (and incidentally ncurses) in the X environment. Several people had made modifications to xterm to support color, but none (except for the completely independent rxvt) implemented background color erase. That is rather like preferring MS-DOS to UNIX. Completely mystifying.
Being bogged down in ncurses, I didnt get involved in xterm until the very end of 1995, after working on atac.
I implemented a workable version of colorized xterm just at the point where XFree86 3.1.2B was announced, complete with a color xterm. As luck would have it, theyd incorporated the "old" color model. So I joined the XFree86 project to fix it.
As I learned more about xterm, I realized that it implemented part of VT220 (i.e., the locking shifts for extended character sets). Since a number of people on the Internet are looking for a good VT220 emulator, it seemed a natural follow-on project to make xterm a good VT220 emulator.
By the release of XFree86 3.2, I had implemented most of the control sequences, except for a handful (DECSTR, the KAM and SRM modes, the ones pertaining to doublesize and soft characters, and of course, blink).
Enhancements:
- The script for installing a man page in a UTF- 8 locale has been fixed.

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.

GXemul is a machine emulator Im developing in my spare time.
GXemul project emulates processors and surrounding hardware components, in some cases well enough to allow unmodified "guest" operating systems to run inside the emulator as if they were running on a real machine.
MIPS:
- Several machine types are emulated well enough to run guest operating systems. NetBSD, OpenBSD, Linux, and even obscure things such as Ultrix and Sprite can run, to various degrees.
ARM:
- CATS is emulated well enough to run NetBSD and OpenBSD as guest OSes.
PowerPC:
- NetBSD/prep can run (experimental).
The emulator can be used for:
- experimenting with operating systems which you have not tried yet, or operating systems for hardware which you might not have access to,
- running guest operating systems for historical purposes, e.g. Ultrix or Sprite,
developing portable software, when you want yet another target platform to try to compile your software on (you can use GXemul to run a guest OS and compile your software inside that OS),
- development of new firmware or operating system code (but then you need to be aware of some limitations),
- educational purposes...
Enhancements:
- NetBSD/pmppc can now run in the emulator (with root on NFS).
- For ARM emulation (with NetBSD/cats, OpenBSD/cats, NetBSD/evbarm, or NetBSD/netwinder as the guest OS), the emulator does not use 100% of the hosts CPU if the guest OS is idle.