Free caml software for linux

Caml is a general-purpose programming language, designed with program safety and reliability in mind. It is very expressive, yet easy to learn and use. Caml supports functional, imperative, and object-oriented programming styles.

It has been developed and distributed by INRIA, Frances national research institute for computer science, since 1985.

The Objective Caml system is the main implementation of the Caml language. It features a powerful module system and a full-fledged object-oriented layer.

It comes with a native-code compiler that supports numerous architectures, for high performance; a bytecode compiler, for increased portability; and an interactive loop, for experimentation and rapid development.

MLdonkey is a multi-platform multi-networks peer-to-peer client. Originally, MLdonkey was the first open-source client to access the eDonkey network. The protocol was reverse-engeneered using an efficient protocol sniffer, Pandora .
Currently, with eDonkey , it supports several large networks, such as Overnet , Bittorrent , Gnutella (Bearshare, Limewire,etc), Gnutella2 (Shareaza), Fasttrack (Kazaa, Imesh, Grobster), Soulseek (beta), Direct-Connect (alpha), and Opennap (alpha). Networks can be enabled/disabled, searches are performed in parallel on all enabled networks, but each file is only downloaded from one network (wait for next release !), but from multiple clients concurrently.
MLdonkey runs as a daemon on the computer. It can be controlled using several interfaces: the simplest one is telnet (telnet 127.0.0.1 4000), a more interesting one is a WEB server (http://127.0.0.1:4080/), and a binary protocol allows access using more elaborate Graphical Interfaces (see the GUIs available on your system at the bottom of the page). MLdonkey comes by default with a GTK interface. All these interfaces can be used locally, or remotely (after disabling security restrictions).
MLdonkey is written in Objective-Caml , a powerful language that runs on most Operating Systems.
Enhancements:
- Ocaml 3.10.0 is now the default compiler
- do not compile unmaintained Gnutella/G2 by default
- non-EDK: Discover WAN IP
- Swarmer: Optional linear downloadBT: Improve UTF8 support
- BT: Support user_commit_dir when seeding
- BT: Fix country-based IP blocking

Polymorphic XML Parser is a validating XML parser for the programming language Objective Caml.
In October, 1999, I started writing a validating XML parser for OCaml; the first published versions have been called "Markup" (simply because the package name was "markup"). After this parser had some success, I decided to revise the whole code, and to redesign the parser where it was needed. The result of this work is PXP, the Polymorphic XML Parser. The name reflects an important property of the parser, namely that the type of the XML nodes can be customized; a feature which is missing in most other XML parsers.
Now, one year later, I can announce the first stable version of PXP. "Stable" means mostly that the interface of the parser has become stable, i.e. future changes will extend but not break the current interface. The parser worked relatively well from the very beginning, and during the pre-release phase (several months) users reported only few bugs. I am now relatively sure that PXP is mature enough to be used in applications.
In general, the task of a XML parser is to read XML text, and to represent the text somehow in memory. There are several models for the data structures; for PXP I have chosen the luxury representation as object tree, in which every XML node is stored as two objects. One object contains the set of methods describing the fixed properties of every node; the other object is called the extension object and can be configured by the user of the parser.
The extension object is the polymorphic part of the representation. The type of the class may be arbitrary (except three base methods which connect the object to the tree), and the parser has a mechanism to dynamically select the class of the object depending on the element type of the XML node.
Main features:
- The XML instance is validated against the DTD; any violation of a validation constraint leads to the rejection of the instance. The validator has been carefully implemented, and conforms strictly to the standard. If needed, it is also possible to run the parser in a well-formedness mode.
- If possible, the validator applies a deterministic finite automaton to validate the content models. This ensures that validation can always be performed in linear time. However, in the case that the content models are not deterministic, the parser uses a backtracking algorithm which can be much slower. - It is also possible to reject non-deterministic content models.
- The parser can read XML text encoded in a variety of character sets. Independent of this, it is possible to choose the encoding of the internal representation of the tree nodes; the parser automatically converts the input text to this encoding. Currently, the parser supports UTF-8 and ISO-8859-1 as internal encodings.
- The interface of the parser has been designed such that it is best integrated into the language OCaml. The first goal was simplicity of usage which is achieved by many convenience methods and functions, and by allowing the user to select which parts of the XML text are actually represented in the tree. For example, it is possible to store processing instructions as tree nodes, but the parser can also be configured such that these instructions are put into hashtables. The information model is compatible with the requirements of XML-related standards such as XPath.
- There is also an interface for DTDs; you can parse and access sequences of declarations.

Waf, previously known as BKsys is a framework based on python for configuring, compiling and installing applications.
It replaces the whole GNU autotool chain (automake, autoconf, aclocal, autoheader, libtool, make) and depends on Python only. Waf features several demos, including KDE3, Qt4 and OCaml sample applications.
Main features:
- Fast rescan for incremental builds (developer working on the project)
- Coloured kernel-like output or progress bar (-v switch to display command-lines)
- Object-oriented target declaration
- Scripts as python modules
- XML script front-end to ease the interaction with integrated development environments
- A c/c++ preprocessor for computing dependencies
- Self-compiling and self-optimizing actions using a syntax similar to the one in scons
- Builddir set by default and with no effort, and now with build variants as well
- Modular configuration scheme with customizable command-line parsing
- Configuration variables are stored in an editable cache
- Real libtool emulation (turned off by default)
- No more hard-coded extensions like .so, .a or .exe
- Tight control over the scheduler (not all links at the end, etc)
- Daemon mode for background recompilation
- Find source files intelligently (glob-like) to ease script maintainance (all c-like classes)
- Support for objective caml and hybrid programs (kde3 program with a part written in caml)
- Support for gnome programs: c and mono (gtk#)
After uncompressing the archive, run:
su -c "./waf.py install"
waf --prepare
cd demos/kde3/
waf configure; waf
Enhancements:
- Running waf without installation uncompresses wafdir under the directory iny ich waf is located (no more home).
- Installing waf under --prefix works as expected. The problems with yellow on white colors have been fixed. Support for reconfiguring the project automatically when a configure function changes has been added. Support for jar files, Python compiled files, and Qt4 translation files has been added. A new compatibility module for Scons scripts has been added. Parallel compilation problems have been fixed.