Free provided that software for linux

Animadead is a skeletal animation library designed to load and play skeletal animations.
Animadead supports models that are composed of several swappable meshes bound to a single skeleton that can be driven by multiple animations. There is an export plug-in for Maya, and others are in development, including plug-ins for 3D Studio Max and Lightwave.
It is written in C++ and has no dependencies. However, an example implementation is provided that uses OpenGL and SDL.
I wrote a shader in CG for OpenGL, which didnt work well on my system, I think due to the best OpenGL CG profile my card supported doesnt utilize the full potential of my card, and I had trouble with passing the list of bone matrices to the card.
The compiler for the supported profile had a ridiculously low number of uniform parameters I could send. So for my simple boxman demo, which has 41 bones or so, I couldnt get it to work, and I didnt feel like making a model with fewer bones.
So after running into a bit of trouble with CG, I wrote a shader in GLSL, which at first had problems as well, but it turns out all I needed to do was upgrade my graphics drivers. Once I did that I got the shader to work, and its nice and fast.
I plan to have both shaders working well and will provide them with the next release.
Main features:
Exporting and file types:
- Custom file types used for meshes and animations.
- Meshes can be static, or deformable and bound to all or a subset of the skeleton.
- Animations use a skeletal hierarchy and local transformations for every bone at every frame.
Loading files:
- The library loads and caches animations and meshes by filename.
- Meshes are broken down into surfaces, which have a texture name, vertices, faces, and a pointer to user defined data.
- A callback function can be set that can load textures when the mesh is loaded, and set the user data for that surface.
- Models in animations can be moving, but when the model is loaded, the movement of the root bone is extracted and removed. This information is stored, and can be used to move the frame of the model at the speed the modeler intended or used to scale the speed of the animation.
Setup (initialize):
- A model is composed of several animations and swappable meshes, but can also contain blends and bone selection masks.
- Blends are used to calculate a pose, usually from two other poses.
- One type of blend is an animation player, which is used to keep track of the current time in the animation and can generate a skeletal pose at that time (between two frames).
- Another type of blend is a blend between blends. When this blend is calculated, it first calculates the two blends its blending, and then blends those together with a user-defined weight. Since this is a recursive definition, blends can in fact be setup in a hierarchy, and the user only needs to call the top level calculate function.
- A bone selection mask is a selection of a subset of the entire skeleton. The hierarchy is used to make the selection process simpler. Essentially, all bones are the same selection state as their parent, unless set directly.
- In addition to being able to calculate a pose from a complex system of blends, the calculate function can be given an optional bone selection mask, which limits the calculations done for that blend to only the subset of bones defined by the selection. This allows you to calculate different parts of a skeleton with different animations.
Drawing:
- The library doesnt actually draw the model, but provides all of the necessary information for your engine to draw the model.
- Data is prepared and organized for use in vertex shaders.
- A pose can be converted to a set of matrix world transformations. (Most shaders like the data like this)
- Examples are shown that actually draw the model.

guile spread is a guile module that conveniently wraps the Spread C libraries provided with the Spread 3.15.2 distribution. Spread is available at http://www.spread.org/.

Spread is a local/wide area group communication toolkit that runs on most modern operating systems.

guile spread allows convenient mechanisms for reliable multicasting information between applications as well as providing many more complicate assurances.

Kitikat Java Framework is a powerful but simple Datastore processing framework.
A Datastore represents an in-memory copy of data.
A program may retrieve the data from a data source, such as a relational database, manipulate the data and then propagate the updates of the data back to the original data source or to a different data source.
Once the data is retrieved, it is a disconnected, data source independent version of the data. A change history of the data is maintained to provide dynamic updates to a data source and there are several levels of concurrency control provided for multi-user environments.
The following applications are supported by the framework:
Java Applications (Stand alone Java applications running in the same Java virtual machine as the framework).
JBoss Application Server (EJBs are provided that support Java applications and web applications).
Sybase Enterprise Application Server (EJBs are provided that support Java applications, web applications, and PowerBuilder applications).
Application Servers (The framework is compatible with all major Java application servers allowing for out-of-the-box implementations).
Web Containers (The framework is compatible with all major Java web containers).
Enhancements:
- This version incorporates the unreleased version 6.11.
- Package restructuring and minor enhancements were done.

selfDHCP is a small network autoconfigure software. It is able to determine the main network configuration parameters by listening to the traffic and with appropriate heuristics. It can run as daemon or as application.
selfDHCP borns from a common need found working on networks: to configure a host in a transparent way. Though this task is greatly performed by many existing tools, such as DHCP, these tools need resources (DHCP servers) that could be not always present, or we would want not to use them. selfDCHP instead doesnt need any external resource, and can work stand-alone.
selfDHCP has two main ways of working. The first is to recognize a known network using profiles, so that it can be used to quickly configure a host on a small network without the need of setting up a DHCP server.
The second is to analyze the network traffic and try to guess the main configuration parameters of an unknown network with heuristic methods.selfDHCP has been written with aim of maximum discretion and stealthness: the great part of the job is done in passive mode, and even when traffic is generated, its stealthness is mantained by spoofing an existing address.
selfDHCP has for now some limits. First, it can only fully work on a non-swithced LAN (i.e. a LAN with a HUB, not a switch), and with ethernet/IPv4 protocols. From current 0.2 version anyway the active mode, combined with profiles, gives selfDHCP the ability to work even on swithced LANs, provided that some informations about the network are known a priori.
Second, it only works on GNU/Linux and other unix-like OSs. It has been tested on GNU/Linux and Solaris, both on x86 and SPARC architectures, and will soon be tested also under Cygwin, and on PPC and Alpha archs.
selfDHCP just passed from its alpha very first release to a more mature beta. Most of the features advertised should work correctly, but the path towards a stable release is still long. For this we strongly need beta testers.
Enhancements:
- Rewritten compilation scripts

Bind9 SNMP Subagent provides indexed BIND 9 statistics via SNMP output. Data, query, and graph templates are provided for Cacti.
Enhancements:
- The duplicate %CFG variable (both in the library and script) has been removed.
- This release supports BIND 9 views.
- There are major documentation updates.

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.

m2psd is a fast MPEG-2 Program Stream demultiplexer. m2psd will demultiplex an MPEG 2 Program Stream into Elementary Streams (ES) or Packetized Elementary Streams (PES), provided that the packs are exactly 2048 bytes long. It was written for use with MPEG 2 Program Streams recorded by a Hauppauge WinTV PVR 250 or 350, and trimmed with Womble (Windows) or GOPChop (Linux).

mp2psd was written because all of the free software MPEG 2 demultiplexers I could find were very slow, and did not output the offset between the first video and audio timestamps.

The input MPEG Program Stream file name must be supplied as an argument for the application.

A base name for the output files may optionally be specified; if none is provided, the base name will be the input file name with all characters from the last dot to the end removed. The output filenames will be of the form basename-n.mpa and basename-n.mpv, for audio and video, respectively, where n is the stream number (0-31 for audio, 0-15 for video).

The "-t" option prints the difference between the first presentation time stamps of the video #0 and audio #0 streams (0xe0 and 0xc0) in milliseconds. This is useful as input to a multiplexer.

The "-a" option discards any partial MPEG audio frame at the start of audio streams, because some software gets upset at partial audio frames.

The "-p" option produces PES streams as output rather than elementary streams. This preserves the time stamps, but many programs cannot deal with PES streams. This option is mutually exclusive with the "-t" and "-a" options.