Free fink software for linux

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

DistccPPCKnoppix is a Knoppix distribution which contains distcc servers for both Linux x86 and OSX ppc compiling. With it you can utilize your extra x86 computers to build Linux x86 and OSX PPC binaries.

After running across "Building a Darwin cross compiler for use with distcc and fink" and "HOWTO: Use Gentoo Distcc Host to cross-compile for OSX" I quickly set out and build my own cross compiler to speed up my Apple OSX development. Like most people I have more x86 hardware then I do ppc. It didnt take long to get it build and a test distccd server up to show that it was working.

When I compile for Linux x86 I use distccKnoppix to utilize all my spare x86 computers I have lying around. Using the Knoppix Remastering Howto I quickly added the ppc cross compiler to distccKnoppix. Now when it boots two distccd demons start on separate ports. The default port (3632) has the x86 compiler and the ppc compiler is on port 3633.

Now Apple developers finally have a use for their x86 hardware (that they can admit to). This is also a nice cheap way to speed up OSX compiling and development.

MegaTunix is the only tuning software for Unix (and now Win32) class operating systems that supports all existing megasquirt firmwares.

MegaTunix has been recently redesigned in such a way as to be extensible to support new firmware variants with little to no new code needing to be written.

The new design permits the gui tabs that relate to MegaSquirt variables to be redesigned using the Glade GUI designer for windows or Glade gui designer for Unix to change or alter the gui look/feel to accomodate new controls on more advanced firmwares.

This tuning software is capable of the most complete interrogation of the ECU than any other tuning software out there currently (MegaTune for windows, MS-Palm, MegaSquirtPCC).

This advanced interrogation is configurable and provides the most complete detection of the target firmware, (such to prevent mis-detection) and would even allow MegaTunix to work with non-MS hardware though this left up as an exercise for the user.

MegaTunix is developed on Linux (Gentoo Linux specifically), but does work on all other Linux distros (Assuming the proper libraries are installed), FreeBSD and Mac OS-X (with fink and the necessary support libraries installed) and now Win32 platforms as of 0.6.1 and newer.

Net::Chat::Daemon is a Perl module to run a daemon that is controlled via instant messaging.

ABSTRACT

This package is intended to serve as a superclass for objects that want to communicate via IM messages within a distributed network of client nodes and a coordinator, without dealing with the complexities or implementation details of actually getting the messages from place to place.

It pretends to be protocol-neutral, but for now and the conceivable future will only work with a Jabber transport. (It directly uses the message objects and things that Jabber returns.)

Note that this package will NOT help you implement an instant messaging server. This package is for writing servers that communicate with other entities via instant messages -- servers written using this package are instant messaging *clients*.

SYNOPSIS

package My::Server;
use base Net::Chat::Daemon;
sub handleHello {
return "hello to you too";
}
sub handleSave {
my ($filename, $file) = @_;
return "denied" unless $filename =~ /^[.w]+$/;
open(my $fh, ">/var/repository/$filename") or return "failed: $!";
print $fh $file;
close $fh or return "failed: $!";
return "ok";
}
sub someMethod {
my ($self, @args) = @_;
.
.
.
}
sub new {
my ($class, $user, %options) = @_;
return $class->SUPER::new(%options,
commands => { callMethod => someMethod,
save => &handleSave });
}

package main;
my $server = My::Server->new(myuserid@jabber.org);
$server->process();

# or to do it all in one step, and retry connections for 5 minutes
# (300 seconds) before failing due to problems reaching the server:

My::Server->run(myuserid@jabber.org, retry => 300);

When you run this, you should be able to send a message to userid@jabber.org saying "hello" and get a response back, or "callMethod a b c" to call the method with the given arguments.

To use the "save" command, youll need to use a command-line client capable of sending attachments in the format expected by this server (it currently does not use any standard file-sending formats).

The jabber command packaged with this module can do this via the -a command-line option.

A note on the implementation: when I first wrote this, it was really only intended to be used with Jabber. The code hasnt been fully restructured to remove this assumption.

pyglplot is a program to 3D-plot mathematical functions and datafiles. It is written as a module for python and as such features the full power and flexibility of the python programming language.
Main features:
Data Sources
- Plot python functions
- Plot python dictionaries containing the coordinates of the points and their position in the grid
- Plot plain datafiles as understood for example by gnuplot
Graphics
- Can make 3D plots of surfaces in normal or parametric mode
- Support coordinate transforms, i.e. can make e.g. polar plots
- Support for pm3d-style coloring of the surface
- Support for wireframe plotting atop of the surface
- Support for transparency: translucent plots
- Support for different types of fog and arbitrary background colors
- Support for dynamic light and specular reflexes etc.
- Use either perspective projection or parallel projection
- Save the rendered plots as portable network graphics (.png)
- Adjust all graphics parameters via dialog windows
Platforms
- This program is developed and tested on Max OS X 10.4 on powerpc with fink and Debian GNU/Linux on i386. It should compile and run everywhere where its prerequisites and requisites thereof are available. These are gtkglext-1.0 and gthread-2.0. Some minimum versions of the libriaries must be met, unfortunately, the gtk+-2.2 packages provided by fink for Mac OS X 10.3 are not sufficient -- perhaps I will port it there.

whohas is a command line tool that allows querying several package lists at once - currently supported are Arch, Debian, Fedora, Gentoo, Slackware (and linuxpackages.net), Source Mage, FreeBSD, NetBSD, OpenBSD, Fink and DarwinPorts.
whohas is written in Perl and was designed to help package maintainers find ebuilds, pkgbuilds and similar package definitions from other distributions to learn from. However, it can also be used by normal users who want to know:
- Which distribution provides packages on which the user depends.
- What version of a given package is in use in each distribution, or in each release of a distribution (implemented only for Debian).
It is suggested you use Unix command line tools to enhance your search results. whohas is optimised for fast execution. This is done by threading, and the order of results cannot be guaranteed. To nonetheless get a standardised output, alphabetically sorted by distribution, use the sort tool:
whohas gimp | sort
You can use grep to improve your search results. Depending on whether you want only packages whose names begin with your search term, end with your search term, or exactly match, you would use a space before, after or on both sides of your search term, respectively:
whohas gimp | sort | grep " gimp"
whohas vim | sort | grep "vim "
whohas gimp | sort | grep " gimp "
The spaces will ensure that only results for the package gimp are displayed, not for gimp-print etc.
If you want results for a particular distribution only, do
whohas arch | grep "^Arch"
Output for each module will still be ordered, so you dont need to sort results in this case, although you may wish to do so for some distributions. Distribution names are abbreviated as "Arch", "Debian", "Fedora", "Gentoo", "Slackware", "SMGL" (Source Mage Linux) and FreeBSD, NetBSD and OpenBSD.
Output in version 0.1 looked like this. The first column is the name of the distribution, the second the name of the package, the third the version number, then the date, repository name and a url linking to more information about the package. Future versions will have package size information, too. Column lengths are fixed, so you can use cut:
whohas vim | grep " vim " | cut -b 36-45
The first bytes of the data fields at the time of writing are 11, 37, 48, 53, 64 and 76.
Debian refers to the binary distribution. Slackware queries Current only. Binary sizes for Fedora are package sizes - space needed on disk will be greater by about factor 2. Binary sizes for Debian are unpacked sizes. All details (including availability, version numbers and binary sizes) are for the x86 architecture.
Debian version numbers in rare cases may not be for x86 (will be fixed). Gentoo version availability may not be for x86 (will be fixed). I recommend you consult the URLs provided in the output, which give detailed and accurate information about each package. You may want to use a terminal that recognises hyperlinks and allows easy access through the browser, such as gnome-terminal.
For Fedora, only release 4 is enabled by default, and only the most up to date package will be listed if different versions are available.
I would like to encourage distributors at this time to provide web query interfaces to package lists, and specifically provide the following information: package name, version, date, size and a url to further information (maintainer, build information etc.)