Free 64bit software for linux

libmtp is an implementation of Microsofts Media Transfer Protocol (MTP) in the form of a library suitable primarily for POSIX compliant operating systems.
libmtp is based on (forked from) the great libptp2 library by Mariusz Woloszyn.
Installation:
Problems with compilation under FC4: GCC4 related problem.
Run this:
CC=gcc32
export CC
./configure
make
Enhancements:
- It uses extended commands to retrieve and cache large metadata sets quickly.
- Is features VERY many new device ID:s and bug flags making it ever more interoperable.
- It fully supports 64bit filesizes. (We hope.).
- It produced udev rules for the new kernels.
- It produces a very bleeding edge HAL style .fdi file.
- Many, many other bug fixes. Notice that the album API in the libmtp.h file has changed somewhat, it should be quite easy to upgrade the existing code. However the album API still needs some overhaul. The library version is bumped to libmtp.so.6 as a consequence of the changes which affects distribution packaging and makes it necessary to recompile applications linking to libmtp.

lighttpd is a secure, fast, compliant, and very flexible Web server which has been optimized for high-performance environments.
lighttpd has a very low memory footprint compared to other Web servers, and it takes care of CPU load. lighttpd has an advanced feature set that includes FastCGI (load balanced), CGI, Auth, Output-Compression, URL-Rewriting, SSL, and much more.
Main features:
Advanced Features:
- virtual hosts
- virtual directory listings
- URL-Rewriting, HTTP-Redirects
- automatic expiration of files
- Large File Support (64bit fileoffsets)
- Ranges (start-end, start-, -end, multiple ranges)
- on-the-fly output-compression with transparent caching
- deflate, gzip, bzip2
- authentication
- basic, digest
- backends: plain files, htpasswd, htdigest, ldap
- fast and secure application controlled downloads
- Server Side Includes
- User Tracking
- FastCGI, CGI, SSI
PHP-Support:
- same speed as or faster than apache + mod_php4
- includes a utility to spawn FastCGI processes (neccesary for PHP 4.3.x)
- via FastCGI and CGI interface
- support Code Caches like Turckmm, APC or eaccelarator
- load-balanced FastCGI
- (one webserver distibutes request to multiple PHP-servers via FastCGI)
Security features:
- chroot(), set UID, set GID
- protecting docroot
- strict HTTP-header parsing
Platforms
Releases of lighttpd are built regulary for at least the following platforms
- Linux (binary packages for FC3, SuSE, Debian, Gentoo, PLD-Linux, OpenWRT)
- *BSD (FreeBSD, NetBSD, OpenBSD, MacOS X)
- SGI IRIX
- Windows (Cygwin)
while it is known to compile cleanly on
- Solaris
- AIX
and various other POSIX compatible OSes.

Blinkensisters is a Parallax-style 2D scrolling gaming system for Linux, Mac OS X, Windows, and POSIX-compatible Unix systems (every platform that can run SDL).

You can make your own levels with a simple text editor.

Installation:

(Now) the game does not have a GNU autoconf/automake based build system, but
compiling the source should be easy:

tar xvzf blinkensisters-VERSION.tar.gz
cd blinkensisters-VERSION
make
make install

That will compile and install "blinkensisters" in /usr/local/bin and the necessary
data-files in /usr/local/share/blinkensisters.

You will (usually) need root-permissions, if you want to install to /usr/local/...
If you do not have root-permissions (or prefer another path for whatever reason), you
can define a PREFIX Variable, e.g.

make PREFIX=$HOME
make install PREFIX=$HOME

will install blinkensisters inside your homedirectory ($HOME/bin/blinkensisters).

You may need to edit the Makefile (e.g. if you compile on Unix-platform, where the
GNU tools are not the standard-tools (I recommend using the GNU commands for building)
or if you have problems, if you are compiling on a 64Bit system)

You will need the following Libraries/(Packages for your distribution):

- A C++ compiler
- GNU Make
- libSDL (+ development packages (Headers, ...))
- libSDL_mixer (+ development packages)
- libSDL_image (+ development packages)
- xutils (Debian), xorg-x11-devel (Suse), x11-devel, xfree86-devel, ...

We tested and successfully build it on the following Unices:

- Suse Linux (9.2, 9.3),
- Debian GNU/Linux 3.1
- Solaris 8,
- SGI IRIX
- the Cygwin environment in Windows

pedsim project is a simple microscopic pedestrian simulation system.

It consists, for the time being, of only a small simulation core and some functions to direct the pedestrians desire. The output of the program is some POV-Ray files generated directly from the main executable (someone needs to separate this eventually), and a data stream in an XML-like format. This stream can be used to attach external viewers in order to watch progress of the simulation in real time. These viewers are available, but are at the moment not under GPL.

This package is suitable for use in crowd simulation (e.g. evacuation), games, and movies. At the moment, it will produce a hard-coded animation sequence of some sword-fighting warriors as an example. If there is enough interest in this simulation package, I will definitely improve the code in a way that it becomes more generally usable (e.g. add a user interface). See the examples page for example pictures, a short movie, and for screenshots.

pedsim was initially developed for RedHat Linux (i686) using gcc 3.2.2, and was tested on a Opteron 64bit machine with Fedora Core 1. It should compile on every POSIX compatible operating system. However, for windos, you might have to change the networking code. You can download the source code.

There is much more code available than presented here. However, not all of that code is under the GPL. Please contact me if you are interested in other software related to this simulation package. Note that the simulation presented here is very similar to the one used in our academical project, but was basically rewritten from scratch. Therefore, contact me as well if you consider using pedsim, since my future efforts on this GPLed project depend on the feedback I get. Please let me know in which direction this project should be extended, and for which purpose this could be of interest to you.

Fink is a package manager that downloads source tarballs from mirror sites, builds them and installs them into a separate directory hierarchy managed using dpkg.
It is a project that wants to bring the full world of Unix Open Source software to Darwin and Mac OS X. As a result, we have two main goals. First, to modify existing Open Source software so that it will compile and run on Mac OS X. (This process is called porting.) Second, to make the results available to casual users as a coherent, comfortable distribution that matches what Linux users are used to. (This process is called packaging.) The project offers precompiled binary packages as well as a fully automated build-from-source system.
To achieve these goals, Fink relies on the excellent package management tools produced by the Debian project - dpkg, dselect and apt-get. On top of that, Fink adds its own package manager, named (surprise!) fink. You can view fink as a build engine - it takes package descriptions and produces binary .deb packages from that. In the process, it downloads the original source code from the Internet, patches it as necessary, then goes through the whole process of configuring and building the package. Finally, it wraps the results up in a package archive that is ready to be installed by dpkg.
Since Fink sits on top of Mac OS X, it has a strict policy to avoid interference with the base system. As a result, Fink manages a separate directory tree and provides the infrastructure to make it easy to use.
Main features:
- Power. Mac OS X includes only a basic set of command line tools. Fink brings you enhancements for these tools as well as a selection of graphical applications developed for Linux and other Unix variants.
- Convenience. With Fink the compile process is fully automated; youll never have to worry about Makefiles or configure scripts and their parameters again. The dependency system automatically takes care that all required libraries are present. Our packages are usually set up for their maximum feature set.
- Safety. Finks strict non-interference policy makes sure that the vulnerable parts of you Mac OS X system are not touched. You can update Mac OS X without fear that it will step on Finks toes and vice versa. Also, the packaging system lets you safely remove software you no longer need.
- Coherence. Fink is not just a random collection of packages, it is a coherent distribution. Installed files are placed in predictable locations. Documentation listings are kept up to date. Theres a unified interface to control server processes. And theres more, most of it working for you under the hood.
- Flexibility. You only download and install the programs you need. Fink gives you the freedom to install XFree86 or other X11 solutions in any way you like. If you dont want X11 at all, thats okay too.
Enhancements:
- fix 64bit-cpu bug

IOzone is a filesystem benchmark tool. The benchmark generates and measures a variety of file operations. Iozone has been ported to many machines and runs under many operating systems.
Iozone is very useful for performing a broad filesystem analysis of a vendors computer platform. The benchmark tests file I/O performance for the following operations:
- Read, write, re-read, re-write, read backwards, read strided, fread, fwrite, random read, pread ,mmap, aio_read, aio_write.
Main features:
- ANSII C source
- POSIX async I/O
- Mmap() file I/O
- Normal file I/O
- Single stream measurement
- Multiple stream measurement
- Distributed fileserver measurements (Cluster)
- POSIX pthreads
- Multi-process measurement
- Excel importable output for graph generation
- Latency plots
- 64bit compatible source
- Large file compatible
- Stonewalling in throughput tests to eliminate straggler effects
- Processor cache size configurable
- Selectable measurements with fsync, O_SYNC
- Builds for: AIX, BSDI, HP-UX, IRIX, FreeBSD, Linux, OpenBSD, NetBSD, OSFV3, OSFV4, OSFV5, SCO OpenServer, Solaris, Windows95/98/NT
While computers are typically purchased with an application in mind it is also likely that over time the application mix will change. Many vendors have enhanced their operating systems to perform well for some frequently used applications.
Although this accelerates the I/O for those few applications it is also likely that the system may not perform well for other applications that were not targeted by the operating system. An example of this type of enhancement is: Database. Many operating systems vendors have tested and tuned the filesystem so it works well with databases.
While the database users are happy, the other users may not be so happy as the entire system may be giving all of the system resources to the database users at the expense of all other users. As time rolls on the system administrator may decide that a few more office automation tasks could be shifted to this machine.
The load may now shift from a random reader application (database) to a sequential reader. The users may discover that the machine is very slow when running this new application and become dissatisfied with the decision to purchase this platform.
By using Iozone to get a broad filesystem performance coverage the buyer is much more likely to see any hot or cold spots and pick a platform and operating system that is more well balanced.
The NFS3 Read Latency graph shows the latency of 4k read operations over an NFS Version 3 filesystem mounted on a client running Iozone.
The NFS3 Re-read Latency graph shows the re-read latency of 4k reads over an NFS Version 3 filesystem. One can clearly see the effects of the client side cache. Here the latencies are the same as local buffer cache latencies.
Enhancements:
- This release adds support for block device testing.
- It adds support for multi-node testing with the full path name to test files.

mubench is an in-depth, low-level benchmark for x86 processors. Its primary goal is to provide useful information for people who optimize assembly code and for people who write compilers. mubench project measures latency and throughput for each individual instruction (sometimes several forms of the same instruction), as well as the throughput of arbitrary instruction mixes. The results produced by mubench are typically an order of magnitude more detailed than those found in AMD or Intel manuals.
mubench results for a variety of processors are available. If you find this information useful, please run mubench on your processor and upload the results.
mubench fully supports all SIMD instruction sets for the x86, including SSSE3, SSE3, SSE2, SSE, MMX, MMX Ext, 3DNow! and 3DNow! Ext. Support for non-SIMD instructions is partial: most data move, binary arithmetic, logical, shift/rotate and bit/byte instructions are supported, but other instructions, particularly branch and function call instructions or instructions manipulating the stack, are not supported. Floating-point instructions for the x87 are not supported. mubench only uses register-to-register (or immediate) forms of the instructions; memory operands are not supported. These limitations will be gradually removed in later releases.
Running:
perl mubench.pl [options]
Options:
--(no-)accurate runs tests several times (default on)
--mhz=2500 processor speed in MHz (normally autodetected from /proc/cpuinfo, set here if that
is wrong, for example if you have SpeedStep enabled)
--(no-)64bit benchmark 64-bit (amd64, emt64, x86-64) instructions (default autodetected)
--(no-)32bit benchmark 32-bit instructions
--(no-)pairs benchmark instruction mixes (default on, very slow; use --no-pairs for a very fast benchmark
that runs in minutes)
--include=add,sub benchmark only instructions matching the given list of patterns (regular expressions ok)
--output=xml|csv|text select output format
--outfile=file.xml output file to save results to (default mubench-results- .xml if xml,
standard output otherwise)
Enhancements:
- the fast form of the benchmark is now default.
- gcc 4.x now works
- a number of non-simd instructions added, support for non-simd is much closer to complete now

QtiPlot is a data analysis and scientific plotting. Free clone of Origin.
QtiPlot uses Qt and the excellent libraries Qwt, GSL, QwtPlot3D and Ingo Bergs Fast Mathematical Parser.
Main features:
- Neat 2D and 3D data plotting
- ASCII-Import
- Spreadsheet and calculations in column-logic
- Great non-linear y=f(x) curve fitting and estimation of statistical errors of the fit-parameters
Whats New in 0.8.9 Stable Release:
- Improved the manual and changed the help system in order to use the powerful QAssistant (it must be placed in the same folder as the qtiplot executable).
- Upgraded to the unofficially released yet version muParser 1.28 which fixes crashes on 64bit machines when working with 3D surface plots.
- Upgraded to the last release of liborigin.
- Added a toolbar for matrix plots.
- Added several toolbuttons to the 3D plots toolbar.
- Improved the automatical layout of 3D plots and fixed a bug in changing the Z scale limits.
- Added the possibility to set the values of a matrix using the x and y parameters as in Origin.
Whats New in 0.9 RC3 Development Release:
- Improved handling of decimal separators.
- Improved 3D plotting.
- Improved import of Origin 7.5 files.
- Lots of bug fixes and improvements.