Mature

Tuareg is a Caml mode for GNU Emacs and XEmacs. It handles automatic indentation of Objective Caml and Camllight codes. Key parts of the code are hilighted using Font-Lock. Support to run an interactive Caml toplevel and debbuger is provided.

Bisect is a coverage tool for the Objective Caml language. It is a camlp4-based tool that allows to instrument your application before running tests. After application execution, it is possible to generate a report in HTML format that is the replica of the application source code annotated with code coverage information.

CamlX is a Wrapper for the OCaml (or Caml Ligth) toplevel environment.
CamlX can be used without a previously installed Caml distribution, indeed it include a Caml Light version. But it is possible to use your own version of Caml (you must specify the path in the preferences menu).

CCSS is a preprocessor/pretty-printer for CSS (Cascading Style Sheets). It extends the CSS language with support for declaration of variables and basic arithmetic operations (addition, subtraction, multiplication, division). The programme is supposed to be used as a filter: it reads the CSS source from stdin and outputs its result on stdout.

GODI bundles the Ocaml compiler with a large list of add-on packages, and serves as a development platform for Ocaml applications. GODI makes it very easy to install open source libraries for all kinds of development areas on your computer. It is intended as a daily toolkit for developers who are mainly interested that the libraries can be pulled into their own projects effortlessly, and do not want to spend half of their life for figuring out how to configure and build software they haven't written themselves.

Mascot is a style-checker for Objective Caml sources. It provides checks in various categories: code, documentation, interface, metrics, and typography. The goal of the tool is to allow a (team of) developer(s) to enforce style properties over a source codebase for greater coherency and style uniformity. The tool is highly customizable, allowing one to choose the checks to perform, as well as exceptions to those checks in given files. Moreover, a plugin system allows the developer to add its own checks, and output modes. Bundled output mode range from bare text to CheckStyle- and JDepend-compatible XML file in order to allow integration with Hudson.

MLcov is a code coverage tool for Objective Caml programs.
It relies on a source code instrumentation technique which allows measuring of Modified Condition/Decision Coverage (MC/DC), the criterion involved in the DO-178B standard to ensure that safety-critical software is tested adequately.
The tool is available as a patch against the version 3.12.0 of the Objective Caml compiler sources.

Neko is an intermediate programming language with
its virtual machine. The compiler is written in OCaml and the VM in C. It
might be interesting for people involved in language design, since Neko is
providing a common reusable runtime for language designers.

OCamlJit 2.0 is a Just-In-Time engine for Objective Caml 3.12.0 on desktop processors (x86/x86-64). It translates the OCaml byte-code used by the interpreter (ocamlrun and ocaml) to x86/x86-64 native code on-demand and runs the generated native code instead of interpreting the byte-code. It is designed to run with minimal compilation overhead (translating only what is being executed, avoiding costly code generation and optimization techniques), while being 100% compatible with the byte-code runtime (including serialization and hashing of closures, etc.).

ODLL is creating a Win32 DLL from an OCaml library, and automatically generating the C stubs needed to interface the OCaml code and the C code and the .H interface. Simply run ODLL with you CMA/CMXA and one or several CMI interfaces and ODLL will do the job for you.

The OCaml Development Tools (ODT) project aims to be like the JDT (Java Development Tools) Eclipse plugins. It provides IDE features for OCaml application developments, such as automatic compilation, custom editors...

Oug is a code analysis tool building reference graphs from OCaml code, that is graphs representing which elements (value, module, class, ...) reference which elements.
It comes with the Ouglib library to be able to embed the analyzer in other OCaml applications.
From the graph, various outputs can be obtained: list of elements not referenced anywhere (useless elements and so potential dead code), various graphiz graphs, ...

Ragel compiles executable finite state machines from regular languages. Ragel targets C, C++, Objective-C, D, Java and Ruby. Ragel state machines can not only recognize byte sequences as regular expression machines do, but can also execute code at arbitrary points in the recognition of a regular language. Code embedding is done using inline operators that do not disrupt the regular language syntax.

ReactiveML is a programming language dedicated to the implementation of interactive systems as found in graphical user interfaces, video games or simulation problems. ReactiveML is based on the synchronous reactive model of Boussinot embedded in an ML language (here OCaml).
The synchronous reactive model provides synchronous parallel composition and dynamic features like the dynamic creation of processes. In ReactiveML, the reactive model is integrated at the language level (not as a library) which leads to safer and more natural programming.

RPC is a package supporting the Sun RPC protocol. RPC programs, procedures, clients, and servers can be dynamically represented and modified. Of course, there is also a classical RPC generator which generates functions doing the language mapping from XDR values to language values and vice versa.

Svgconv is a tool to convert SVG paths into a C format that can be easily used with OpenVG. The tool converts SVG graphics into C source code that can be #included into your C program that wishes to use the path data.

SWIG is a software development tool that connects programs written in C and C++ with a variety of high-level programming languages. SWIG is primarily used with common scripting languages such as Perl, Python, Tcl/Tk, and Ruby, however the list of supported languages also includes non-scripting languages such as Java, OCAML and C#.

WideStudio is an open source, Integrated Development Environment for desktop applications purely made in Japan. This enables you to develop GUI applications that can run on Windows95/98/Me/NT/2000/Xp/Vista, WindowsCE, Linux, FreeBSD, SOLARIS, MacOSX(w/X11), BTRON, T-Engine, mu-CLinux(wo/X11) in various programming languages such as C/C++, Java, Perl, Ruby, Python, Objective Caml.
Since an application is build on MWT(Multi-Platform Widget Toolkit) which runs on multiple platforms, WideStudio applications are all source compatible between these platforms.

Beta

AlphaCaml is a tool that turns a so-called ``binding specification'' into an Objective Caml compilation unit. This helps writers of interpreters, compilers, or other programs-that-manipulate-programs deal with alpha-conversion in a safe and concise style.

Aurochs is a parser generator that uses the parse expression grammar
(PEG) or "packrat" approach. It takes a grammar in a BNF-like notation
(a .peg file) and produces bytecode (a .nog file) for a stack automaton.
This bytecode is later interpreted on the input to parse using a C
library. Bindings are given for Ocaml and Java. Aurochs can also
directly produce C or Ocaml code for parsing. It is in use
at Exalead where we use it daily to parse real-world Javascript.

BER MetaOCaml is a streamlined version of MetaOCaml -- a conservative extension of OCaml with the primitive type of code values, and three basic multi-stage expression forms: Brackets, Escape, and Run.

Cppo is an equivalent of the C preprocessor targeted at the OCaml language and its variants.
Its main purpose is to provide simple macro substitution (#define) and file inclusion (#include) for the occasional case when this is useful in OCaml.
The implementation of cppo relies on the standard library of OCaml and on the standard parsing tools Ocamllex and Ocamlyacc, which contribute to the robustness of cppo across OCaml versions.

A system
to interface OCaml and .Net/C#. CSML makes it possible to leverage
existing .Net components from OCaml, to expose OCaml libraries into the
.Net world and more generally to write mixed OCaml/.Net applications.
With CSML, developers write scripts that describe interactions between
the two worlds (OCaml and .Net). It is possible to bind functions,
static or instance methods, properties, to pass opaque pointers from one
heap to the other, or to copy values structurally. CSML preserves type
safety properties from the two worlds, it propagates exceptions and
first-class functions in a sound way and it deals automatically with
memory management.

FoCaLize is an integrated development environment to write high integrity
programs and systems. It provides a purely functional language to formally
express specifications, describe the design and code the algorithms. Within
the functional language, FoCaLize provides a logical framework to express the
properties of the code. A simple declarative language provides the natural
expression of proofs of those properties from within the program source code.

Hydro is an independent implementation of ICE, the object-oriented RPC protocol by ZeroC, for the O'Caml programming language.
Hydro (like ICE) allows you to bridge language barriers by letting components written in different programming languages communicate with each other. ZeroC's ICE product currently includes implementations for C++, Java, C#, Python, Ruby, VB, and PHP. Hydro adds support for O'Caml. The ICE protocol is rich enough to make the representation of the data to communicate easy and convenient to use, and adopts an object-oriented type system. ZeroC sees ICE as a superior successor to CORBA.

Katmake is an GNU automake-like utility for the OCAML language.
It is designed for generating Makefile for OCAML language. You give it a `Makefile.am' describing the project as input and it produces a Makefile. This Makefile is able to build all the project, to perform or to remove the installation, to build the distribution and to remove temporaries files.

Mingw-builds is an ongoing project that creates a set of open-source libraries and tools for windows in a clean and reproducible way, making it possible to easily build for windows. It uses yypkg, a cross-platform, system-agnostic and cross-compilation-friendly package manager. Both of them will become official tools and repositories for the mingw-w64 project.

Mocac is a generator of construction functions for Caml concrete data types with algebraic invariants and maximal sharing facilities. Algebraic invariants are specified by using keywords denoting equational theories like commutativity and associativity. The construction functions generated by Mocac allow each equivalence class to be represented by a unique value.

NJoy is a variant of the concatenative programming language Joy The main difference is that it is enriched with an easy to module system with optionally private declarations.
Only a part of the standard library of Joy is implemented. The interpreter is easy to use, but the builtin functions are poorly documented. The performance of the interpreter (natively compiled and stack traceback switched off) is on par with optimized C implementation of Joy.

O'Jacare is a code generator to help in interoperability between Java and O'Caml through their object model. O'Jacare defines a simple IDL for Java's classes and interfaces descriptions. For communications from Java to O'Caml it owns a callback mechanism. So, you can easily override in O'Caml a method defined in Java. The implementation is based an each language low-level interfaces with C (JNI for Java and external for O'Caml) and uses an extended version of the camljava library. O'Jacare generates all needed wrapper classes and enables static typechecking in both world.

OASIS can integrate configure, build and install systems in their projects. It helps to create standard entry points in the source code build system and allows external tools to analyse projects easily.
It is inspired by Cabal which is the same kind of tool for Haskell.

OCaml Metrics is a simple OCaml code analysis tool. It can compute some metrics of functions and modules: cyclomatic complexity, the number of lines of code, Halstead complexity measures (difficulty, volume and effort) and Maintainability Index. OCaml Metrics generates reports in three formats: HTML, simple XML or plain text.
This allows developers to find parts of their projects which need refactoring in order to keep the projects easily maintainable.

Ocaml-data-notation, aka odn, dumps OCaml data in OCaml notation. It
is inspired by JSON. It uses type-conv to create data dumper functions,
you just have to add "with odn" in the type definition. There is no
load scheme, since it is used to dump datastructure into OCaml scripts.
It is mainly a code generator helper.

This is a simple implementation of `expect` to help building unitary testing of interactive program.
You can match the question using a regular expression or a timeout.
See the Expect manual for more information:
http://expect.nist.gov/

OCaml-gettext provides enough service to build a basic internationalized program. It comes with a pure Ocaml implementation, based on Camomile, a binding to GNU gettext library, and ocaml-gettext, a tool to extract strings from Ocaml source.

An ocamlbuild plugin that supports compiling C and C++ cross platform
using ocamlbuild only.
Variant builds - can build many different variants from the same
source tree. For example static libraries, test builds, debug,
optimization, linking or not linking with some other code, different
platform builds etc.
Automic recursive header file generation - needed for pulling source
into _build directory.
It used to be able to rebuild on header file change, but it has
regressed - it is possible that .stamp files do not hold signatures of
dependencies of dependencies or something.
It has not been tested on Windows, but build rules have been copied
from old build scripts so it should not be that hard to get going.

Ocamljs compiles OCaml to Javascript. It uses the standard OCaml
front-end, so the full language is supported (the object system is
partially supported, should be fixed soon).
Included are several libraries for Web programming, as well as a
library for working with Javascript via Camlp4. It works with orpc for
RPC over HTTP, and with froc for functional reactive browser
programming.

The ocamlnat project provides a new native code OCaml toplevel ocamlnat, which is mostly compatible to the byte code toplevel ocaml, but up to 100 times faster. It is based on the optimizing native code compiler, the native runtime and an earlier prototype by Alain Frisch. It is build upon Just-In-Time techniques and currently supports Unix-like systems (i.e. Linux, BSD or Mac OS X) running on x86 or x86-64 processors. Support for additional architectures and operating systems is planned, but not yet available.

OCamlTeX is a combination of an OCaml script and LaTeX style file that, together, give the user the ability to define LaTeX macros in terms of OCaml code. Once defined, a OCaml macro becomes indistinguishable from any other LaTeX macro. OCamlTeX thereby combines LaTeX's typesetting power with OCaml's programmability.

Olmar connects Elsa, the Elkhound based C/C++ parser and typechecker, with Ocaml. More precisely, the Olmar extension can translate Elsa's internal abstract syntax tree into a value of an Ocaml variant type. This value can then be further processed with a pure Ocaml program. I prefer to have standalone Ocaml programs. Therefore I let Elsa marshal the abstract syntax tree as an Ocaml value to disk. However, it is also possible to link the Ocaml code into the Elsa executable.

Orpc is a tool for generating RPC clients and servers. It can generate
clients / servers for use with Ocamlnet's ONC RPC implementation (like
ocamlrpcgen), and also for RPC over HTTP for use with ocamljs. To
describe interfaces, you give orpc an OCaml signature instead of an
RFC-1831/1832-format file. Most OCaml types (including polymorphic
types), exceptions, and functions with labelled/optional arguments are
supported.

P4ck (read "4-pack") is a utility which downloads, compiles and installs Camlp4 syntax extensions. The motivation for this tool comes from the fact that many people wrote interesting syntax extensions for OCaml, which are in fact quite short and fit in one single file.

This is a meta build system.
It is implemented as an ocamlbuild plugin.
It checks out source code from repositories and starts builds of
individual components.
Because ocamlbuild doesn't support linking additional files, a lot of
different code is collected in a single file. This includes a JSON
parser for configuration files.
Symbiosis tries to avoid the problem of collecting all source
dependencies in one large tree, or alternatively installing
dependencies on the system. The former makes it difficult to change
dependent component versions. The latter makes it difficult to quickly
test different build version complicates developer setup.
Correctly configured, just call ocamlbuild with a target for the top
most component to build. All the source should be appear in the
working directory and build.
Initially it can be complex to set up, but once done, it is rather
easy to add new components with interesting dependencies.

Syncweb is a command line tool enabling programmers to use the
literate programming development methodology, using the noweb
tool, while still being able to modify the generated files
from the literate document. syncweb provides a way to
"synchronize" the possibly modified original document with its
possibly modified views with an interface similar to Unison. In
addition, syncweb synchronizes data at a fine grained level by
computing and storing md5sum of the different chunks.

OCaml development environment, developed by OCamlPro and Inria Saclay.
This version of TypeRex only integrates with Emacs and brings a
collection of new features that programmers expect from a modern IDE.
Next versions will target more editors.

WOWcamldebug is a front end that permits to use the OCaml debugger with (g)vim. You can run it as you usually run ocamldebug and it will execute both the ocamldebugger itself, permitting usual interaction, and a gvim window which will be kept in sync with the current debugging position. The current debugging line is highlighted and the cursor is positioned at the current event position on that line.

A plugin for integrating OCaml in Xcode. At this time, it's still a beta version but it now works on simple tasks like syntax coloration, creation of a native ocaml target, and adding .m files or .cma static libraries to the target, integration of ocamllex and ocamlyacc, integration into the Xcode build system, error window.

XStream is a simple functional transformation language for XML documents. XML transformations written in XStream are evaluated in streaming: when possible, parts of the output are computed and produced while the input document is still being parsed. Some transformations can thus be applied to huge XML documents which would not even fit in memory.

Alpha

Given a cursor position (line 30, column 20) "annot -type 30 20 main.annot" looks up the type
annotation for that position in main.annot. It is trivial to hook this
to a key in Vim, and probably most other editors.

A Linux -> Win32 OCaml cross-compiler, developed and sponsored
by Red Hat's Fedora MinGW project[1]. Red Hat are sponsoring this
project so that we can build our OCaml virt tools for Windows without
the hassle of using Windows.

Pasta is a cross-assembler for the MOS 6502 (also including 65C02 instructions), which
contains experimental support for automatic management of certain resources
(namely, zero-page memory locations), provided that you are prepared to use a
slightly restricted programming style.

Saffire is a static analysis program that detects bugs in programs that use the OCaml/C foreign function interface. Saffire works by performing type inference across both OCaml and C to make sure that values are used consistently across the language boundary. For instance, if a OCaml passes a record to a C function, that C function should not treat the data as an integer. Saffire also tracks what C variables point into the OCaml heap and ensure they are always registered with CAMLparam/local before any allocation functions are called.

A unit testing framework for OCaml. It is based heavily on the Perl unit testing framework of the same
name, and produces TAP output (http://en.wikipedia.org/wiki/Test_Anything_Protocol) which can be read and analyzed by a wide
range of existing Perl tools. The goal of this framework is to make
writing unit tests as simple and as easy as possible (hence the
name).

OCamlify allow to create OCaml source code by including whole file into OCaml string or string list. The code produced can be compiled as a standard OCaml file. It allows embedding external resources as OCaml code.