Free assorted software for linux

The current version contains functions for 1D, 2D, and 3D images, which may be greyscale, color, or multispectral.
Enhancements:
- A limitation in SaveData and LoadData that restricted the size of data has been fixed.
- There are assorted other minor bugfixes.

portmap is a part of the ONCRPC collection of software for implementing remote procedure calls between computer programs. This project is use widely by NFS and NIS, and assorted other systems.
Some make variable can be used to control compilation.
NO_TCP_WRAPPER= if non-empty, doent use tcp_wrappers
USE_DNS= if set, tcp_wrappers can check peers based on hostname
as well as IP address. This should only be used if you
are certain that gethostbyname will never trigger a
called to portmap (as it might if nis is used for hostnames).
RPCUSER= is set, portmap will use getpwnam to find the user for
that user, and will setuid to that user before listening
for incoming messages
DAEMON_UID= Can be set to a number to override the default UID
to setuid to. Default is 1.
DAEMON_GID= As above, but for setgid.
Enhancements:
- This first new release in 10 years combines assorted patches from different Linux distributions.
- Security was improved so that privileged services can register non-privileged ports that cannot then be unregistered by other users.

ScryMUD project is a MUD with a Java client.
ScryMUD is a MUD written completely from scratch that has a full feature set including persistant belongings, a ree-based skill/spell system, game-navigated vehicles, complex scripting, player-owned stores and houses, and much more. The distribution also comes with Hegemon, a Java client that provides a nice UI for ScryMUDs Online Building.
Main features:
- Completely original world and code. We have 6000+ rooms, 400+ mobs and 400+ objects.
- Integrated Java Client (applet/application) which offers a nice interface to the game and to the Online Building tools.
- Player controlled shops (you get the goods, set the prices, and collect the dough.)
- Can Brew potions. This requires the brew skill, a cauldron, and the necessary ingredients.
- Can Scribe Scrolls. Requires a scroll, pen, and knowledge of the spell.
- Spells become less powerful when there are many scrolls/potions that can cast them in the game. This balances the above features.
- Skills and Spells are learned in a tree-like manner. You must learn the pre-requesites to at least 50% before you can move on to the skills/spells it enables. So, you can customize the character to your liking and are limited only by the number of practices you have.
- Game-navigated vehicles (though not widely used in the game yet.)
- Complex NPC scripting so that the builders can make quests and other interesting things.
- Mobs have some personality traits, which can influence their behavior in battle and afterwards. Some will track you down and kill you (and then return to their starting point. Others may heal you if you are badly hurt.
- Bulletin boards for in-game communication, as well as gossip, yell, and other channels.
- Banks to keep your cash safe for you.
- Configurable ANSI color.
- Some multi-lingual capability.
- Released under the GPL
Enhancements:
- This release includes the addition of weather, several new spells and socials, minor improvements to ranged combat, and assorted bugfixes.
- Daemonizing code in particular should be a bit safer now.

ACE short from ADAPTIVE Communication Environment is an object-oriented (OO) C++ framework that can help you develop and deploy high-performance software systems faster and better.
ACE is especially useful for systems that use network and/or inter-process communications and that take advantage of multithreading. While the ACE source code is free, thats not the only way you save money with ACE.
ACEs wrappers and higher-level patterns help you develop your software quickly and portably, helping you to complete your projects on time and within budget.
Over the past decade, my research group has worked with many collaborators on large-scale distributed application R&D projects in diverse domains, including command and control systems, telecom, datacom, medical engineering, distributed interactive simulations, and financial services.
Regardless of the domain and application requirements, weve found that software developers wrestle with the same core infrastructure challenges. Key challenges focus on OS platform portability, connection management and service initialization, event demultiplexing and event handler dispatching, multi-threading and synchronization, fault detection and fault tolerance, and various quality-of-service (QoS) issues, such as controlling latency, throughput, and jitter end-to-end.
Unfortunately, its very costly, time consuming, and error-prone for researchers and developers companies to independently rediscover and reinvent ad hoc solutions to these core distributed application software development challenges.
Fortunately, we have identified a relatively concise set of patterns and framework components that can be applied systematically to eliminate many tedious, error-prone, and non-portable aspects of developing and maintaining distributed applications.
A decade of intense R&D on these topics has yielded ACE, which is an object-oriented framework that implements many core patterns for concurrent communication software. We have applied the patterns and components in the ACE framework to develop The ACE ORB (TAO), which is our standards-based, CORBA middleware framework that allows clients to invoke operations on distributed objects without concern for object location, programming language, OS platform, communication protocols and interconnects, and hardware.
TAO is designed using the best software practices and patterns that we have discovered in our work on ACE in order to automate the delivery of high-performance and real-time QoS to distributed applications.
Enhancements:
- This release adds support for Intel C++ specific optimizations for Linux on IA64.
- It improves support for ACE_OS::fgetc, and adds support for other low-level I/O.
- Shared library builds on AIX now produce a libxxx.so file.
- A workaround has been added for a bugfix in GCC in Fedora Core 7.
- The footprint has been reduced on some platforms.
- Major improvements have been made to IPv6 support.
- TAO DDS enhancements have been added.
- There are assorted bugfixes and other minor enhancements.

64 Studio is developing a collection of software for digital content creation on x86_64 hardware (thats AMDs 64-bit CPUs and Intels EM64T chips).
Its based on the pure 64 port of Debian GNU/Linux, but with a specialised package selection and lots of other customisations.
64 Studio has Debian Pure 64 with X.org, the Gnome desktop, kernel 2.6.12 with realtime preemption patches and a selection of creative applications. Please note that this release is provided for testing only, and comes with no warranty.
Problems in this release include useful packages missing or not installed by default, confusing Gnome menus and assorted warnings during installation. There are probably plenty of other things wrong with it as well, which is why were calling this an alpha release. But it does actually install and run on our Opteron and Athlon 64 test hardware.
Anyone who is interested in getting involved with the 64 Studio project would be most welcome. Our aim is to create a distribution with full (but completely optional) commercial support, which will generate revenue to pay free software developers.
Enhancements:
- 64 Studio 2.0 is designed to retain compatibility with Debian Etch, to create a long-lived and stable creative desktop. We combine the stability and quality of Etch with a specialised real-time preemption kernel and the latest creative tools demanded by multimedia artists. Our tweaks to Debian include simplified installation and default settings which help get production underway quickly. Its our target that users should be able to get from a blank hard disc to a fully hardware-optimised and usable creative desktop in just half an hour.

system-config-printer purpose is to configure a CUPS server (often the local machine) using the CUPS API. The tool is written in Python, using pygtk for the graphical parts and with some Python bindings (pycups) for the CUPS API.
It is largely the same as using the CUPS web interface for configuring printers, but has the advantage of being a native application rather than a web page. It appears in the Fedora menu under System -> Administration -> Printing.
As a result of using the CUPS API the tool is able to configure remote CUPS instances and is not limited to configuring CUPS on the local machine. The CUPS library providing the API uses HTTP and IPP to communicate with the CUPS server.
Enhancements:
- Several improvements for the new-printer wizard have been made, and assorted bugs have been fixed.

WWW::Yahoo::Groups::Errors is a Perl module with exception classes for WYG.

This class provides assorted exceptions for the use of the other modules.

INHERITANCE

All errors are subclasses of X::WWW::Yahoo::Groups which is a subclass of Exception::Class::Bass. See Exception::Classs documentation for methods available on the errors.

EXTRA METHODS

Beyond what Exception::Class provides, there are two extra methods.
fatal

fatal will return true if the error caught should be one that terminates the process.

AVAILABLE CLASSES

These should be obvious from their name. If not, please consult the source or use the description method.

X::WWW::Yahoo::Groups::BadParam
X::WWW::Yahoo::Groups::BadLogin
X::WWW::Yahoo::Groups::NoHere
X::WWW::Yahoo::Groups::AlreadyLoggedIn
X::WWW::Yahoo::Groups::NotLoggedIn
X::WWW::Yahoo::Groups::NoListSet
X::WWW::Yahoo::Groups::UnexpectedPage
X::WWW::Yahoo::Groups::NotThere
X::WWW::Yahoo::Groups::BadFetch
X::WWW::Yahoo::Groups::BadProtected

USE OF THIS MODULE

Due to the nature of how Params::Validate works, we store common options for it in this class (as they mostly relate to error handling). Thus, you should import this module with the following idiom:

require WWW::Yahoo::Groups::Errors;
Params::Validate::validation_options(
WWW::Yahoo::Groups::Errors->import()
);