The Caml Hump: Development tools

jsonpat is an application for the easy transformation of JSON files.

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.

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.

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.

Protocol Buffers, JSON and XML serialization".

This is a very preliminary release of CamlJava, an OCaml/Java interface. Currently, it provides a low-level, weakly-typed OCaml interface very similar to the JNI.

Generation of stubs for Caml-to-C interface based on a .h header file (work in progress, not yet complete).

A powerful logic design language that combines the dataflow and component-based methodologies of HDL with the expressiveness of modern functional programming.

A foreign function interface package for Objective CAML. It reads C header files and generates a mix of C code and ocaml external declarations.

A program for generating language bindings based on C header files.

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.

Eff is a functional programming language based on algebraic effects and their handlers.

Diamondback Ruby (DRuby) is an extension to Ruby that aims to bring the benefits of static typing to Ruby without compromising the expressiveness of the language.

Jsure is a "lint" for Javascript, which is also known as Ecmascript. It checks syntax and a little bit of semantics.

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.

A static analyzer of spurious exceptions of OCaml programs.

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.

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, ...

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.

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.

Extension of the Objective Caml compiler suite producing Java binaries (.class/.jar files).

A library for communicating between python and OCaml, together with a little proof-of-concept interface to WxPython, as a first step towards a better GUI tool for OCaml.

Js_of_ocaml is a compiler of OCaml bytecode to Javascript. It makes it possible to run Ocaml programs in a Web browser.

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.

A simple but efficient compiler from a tiny ML subset to the SPARC assembly language.

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.

This is a port of the OCaml compiler to AIX (PPC) and HP-UX (HPPA).

The goal of the OCaml-Java project is to allow seamless integration of OCaml and Java.

ocamlclean takes a bytecode executable (which are generally but not necessarily produced by "ocamlc" compiler) and reduces its size by eliminating some dead code.

Defunctorizer for OCaml.

OCamlDuce is a merger between OCaml and CDuce. It comes as a modified version of OCaml which integrates CDuce features: expressions, types, patterns.

An experimental branch of the O'Caml compiler: O'Caml extended with Generalized Algebraic Datatypes.

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.).

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.

A project which brings OCaml to programming PIC micro-controllers.

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.

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.

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.

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.

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.

PML will be a proof assistant based on a variant of the ML programming language which should also allow to write mathematics.

A tool to distribute pieces of OCaml code in a way similar to apt-get.

A simple and lightweight tool for managing headers in source code files.

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.

FORT (Framework for Ocaml Regression Testing) provides an environment for testing programs and Objective Caml modules.

Kaputt is a testing tool for the Objective Caml language.

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.

Integrated Logging, Assertion, and Unit Testing library

Unit test framework for ocaml. It is based on HUnit, a unit testing framework for Haskell.

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).

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.

Camlp5 is a preprocessor-pretty-printer of ocaml. It is the continuation of the classical Camlp4 with new features. It is compatible with OCaml versions from 3.08.1 to 3.11 included.

A small template processor library for Objective Caml. It can be used to generate web pages, scripts, SQL queries, XML documents and other sorts of text files.

Fan is a full blow programming language, it’s a superset of ocaml with Lisp-like macro’s features. It shares the same run-time with ocaml, so it’s 100% compatible with ocaml.

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.

An Emacs minor mode for automatic look up OCaml Info files.

A vim plugin to handle annot files.

Smart-indent macros and syntax hilighting for OCaml code with NEdit.

OCaml syntax file for the VIM-editor.

A source code tagger for OCaml that can be plugged in to GNU Global's tag set up.

OMLet provides a much better indentation for Caml/OCaml files than the official one. It mostly behaves as tuareg-mode for emacs does. Omlet supports most of the language features, including objects.

An Emacs tag generator for Ocaml source files, working also with syntaxes extended with Camlp4.

Vim tag file generation for OCaml.

OCaml tag file generator.

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.

Tuareg imenu is an extesion for Emacs of the tuareg mode (it do not work under XEmacs). It help to have an global visoin of you code

A ViM extension that is able to parse .annot files and print the type of an highlighted (visual mode) part of an ocaml source file.

A tool to create hilighted html pages from OCaml files (.ml, .mli, .mll and .mly).

An application that produces LaTeX2e code from caml (OCaml, Caml light) source files.

This little piece of code displays the internal representation of Caml values. It produces a graph as an ASCII file, in a format suitable for the `dot' tool.

Highlight converts source code to formatted text with syntax highlighting. Features include coloured output in HTML, XHTML, RTF, TeX, LaTeX and XML format; Support for 120+ programming languages; include 40 colour themes; platform independent; customizable and easy to use. OCaml is also supported.

Automatic documentation extraction for Objective Caml.

A CWEB like literate programming tool. It is designed to target all languages and actually has a version targeting the MATLAB language.

Generation of program dependency graphs for OCaml programs, using dot.

A program to count the lines of code and documentation in ocaml sources.

A literate programming tool for Objective Caml.

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.

A group of plugins to add OCaml support in the Eclipse IDE. It provides very basic support for creating OCaml projects, editing source files, building and running.

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).

A small utility to mine cmi files for interesting bits of data.

CocOCaml is a Cocoa based wrapper for the OCaml toplevel environment.

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.

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.

Merlin is a tool which providessmart completion, among other things, in your favorite editor. As of today, Vim and Emacs are supported.

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.

Compile and run native functions from the toplevel.

OcaIDE is an O'Caml plug-in for Eclipse

Batteries Included is a candidate standard development platform for OCaml.

This plugin extends the support of NetBeans IDE for projects written in Objective Caml Language.

Ocaml-MinGW-Maxi is binary distribution for OCaml port for Windows based on the MinGW toolchain. It contains the OCaml compiler and some precompiled add-on libraries.

OCamlEditor is a source code editor and build tool for OCaml written in OCaml+LablGTK working under Windows.

Annotate uncaught exception stack traces in a readable and editor-friendly way.

A small compiler patch which extends -annot option and records all the variable definition locations, so that we can jump from variable uses to their definitions easily from editors such as emacs.

Extension of the OCamlwin tool to add edition facilities, and more.

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...

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.

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.

utop is a toplevel for OCaml which can run in a terminal or in emacs. It supports completion, colors, parenthesis matching, ...

VisualML is an OCaml project wizard for Microsoft Visual Studio. It enables easy creation, compilation and errors corrections of OCaml projects under Visual Studio.

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.

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.

YYPkg is a small, fast, platform-agnostic package manager. It can be used to manage any directory. It is built to help cross-compilation setups and it works both for and on Windows.

The key idea of Ocamlviz is the ability to instrument an existing code, in real time, with lightweight monitoring annotations. Ocamlviz can also be used as a debugging tool.

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.

Atdgen is a command-line program that takes as input type definitions in the ATD syntax and produces OCaml code suitable for data serialization and deserialization.

Development environment for Objective Caml programmers, written in GTK2. It includes an OCaml-scriptable text-editor, a graphical toplevel, a documentation browser, and other useful tools and libs.

CamlIDL is a stub code generator and COM binding for Objective Caml.

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.

Menhir is an LR(1) parser generator for the Objective Caml programming language.

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.

Bridge/Bindings generator for Java/Objective Caml integration.

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.

OCaml-gir is an automated binding generator for glib-based libraries.

Generate a dynamic-programming ocaml code from a pattern matching specification.

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.

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#.

Automli is a small program for O'Caml programmers which automatically generates MLI files from ML files and a specification of which functions, types etc. to export or hide.

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 simple OCaml packager.

A library manager for Objective Caml.

CGI script that browses packages managed by findlib.

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.

GODIVA, the GODI Verpacken Assistant, is a tool for making GODI packages.

A little helper tool to simplify using Microsoft command line build utilities in a unix-like way.

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.

Incrementally rebuild OCaml programs as source code evolves

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.

An automatic compiler for the OCaml language (has special features for integration under MS Visual Studio).

Autoconf macros to support configuration of OCaml programs and libraries.

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/

ocamlbrew aims to be a simple tool for getting up and running with various versions of OCaml. The concept, along with some basic code, is borrowed from perlbrew.

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.

Ocamlbuild-plus is an extension of ocamlbuild that enables to use findlib packages in its build plugins.

Ocamlconf is like autoconf but much simpler, utterly ocaml-centric, and dependent on findlib.

A tiny command line tool to sort .ml files according to their dependencies, in order to link the corresponding .cmo files.

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.

Automated compilation of complex OCAML-projects.

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.

OMake is a build system designed especially for large projects. It uses a syntax similar to make utilies you may have used, but with enhancements.

A sample configure.in to provide configure scripts for OCaml projects, and the associated Makefile.in.

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.

Wodi is a godi-based ocaml distribution for windows. Its build system and package management tool rely on cygwin, but the binaries - compiled with mingw-w64 and ocaml - are independent of cygwin.

Another build system for OCaml... The idea is to write a Makefile.ml, using the YaM helper module, and to compile it to get a project specific make.

This project helps to create self contained Ocsigen web server with its Eliom modules. It is a mean to easily deploy an Ocsigen server on a server without OCaml installed.

OCamlP3l is a compiler for Caml parallel programs. The OCamlP3l programming paradigm is skeleton programming. The skeletons encapsulate basic parallel programming patterns in a well understood and structured approach. Based on P3L, the Pisa Parallel Programming Language, OCamlP3l skeleton algebra is embedded in a full-fledged functional programming language, namely Objective Caml.

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.

An OCaml curses editor to write coloured texts or draw things.

xml2cd is a cduce preprocessor that lets you embed cduce expressions in an xml files (and vice-versa) à la php (but with the nice cduce type checking). It supports namespaces, automatic dtd downloading etc...

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.

SimpleSOAP is an early, experimental SOAP client for Objective CAML.

Opa is an open source, web development platform designed specifically for the Web with both security and developer agility in mind.