The Caml Hump: Open Source :: LGPL

Active-DVI is a Unix-platform DVI previewer and a programmable presenter for slides written in LaTeX.

Interface to Google Adwords API. This API offers rapid, type-safe development, command line tools for doing common Adwords operations, interactive access to the API.

A library to help writing distributed programs. The library manages all the details relevant to process launching, channel creation, and network communication so as to let the programmer stick to the core of the problem. This allows to write programs that can be distributed on several machines in a concise way, with all the parallel aspects kept implicit (no synchronisation).

Amthing is a multi-threaded GUI library for Objective Caml.

Ancient is an OCaml module that allows you to use in-memory data structures which are larger than available memory and so are kept in swap. If you try this in normal OCaml code, you'll find that the machine quickly descends into thrashing as the garbage collector repeatedly iterates over swapped memory structures. This module lets you break that limitation. Of course the module doesn't work by magic :-) If your program tries to access these large structures, they still need to be swapped back in, but it is suitable for large, sparsely accessed structures. Secondly, this module allows you to share those structures between processes. In this mode, the structures are backed by a disk file, and any process that has read/write access that disk file can map that file in and see the structures.

THis library contains a lot of the routines the author find needing all the time that aren't in the standard library (Especially string searching and manipulation), and some other odds and ends that are useful at times. Highlights include wildcard globbing, lots of string searching and manipulation routines, locale support, ~user-style path expansion, and more.

This package provides basic interface to Linux APM driver for Objective Caml programs.

a high quality, platform-independent, and extensible 2D plotting library for OCaml.

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.

A data structures library.

Library for Java .class file manipulation. Also a command-line [dis]assembler for Java.

A binary protocol generator.

The ocaml-bitstring project adds Erlang-style bitstrings and matching over bitstrings as a syntax extension and library for OCaml. (This project was formerly known as "bitmatch"). You can use this module to both parse and generate binary formats, files and protocols. Bitstring handling is added as primitives to the language, making it exceptionally simple to use and very powerful.

A bit vectors library.

Bolt is a logging tool for the Objective Caml language. It is inspired by and modeled after the famous log4j logging framework for Java.

A simple interface to the commercial Boom SMS (text message sending) service.

Java port of ocamlrun, runtime support for Cafesterol.

Objective-Caml bindings for the Cairo library.

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.

Inspect is a small library to inspect arbitrary OCaml values and their associated object graph by either dumping them as S-expressions (with sharing and references), or by writing output in the DOT-language which can then be further processed by Graphviz (http://www.graphviz.org/).

CamlBZ2 provides OCaml bindings for libbzip2, a popular compression library which typically compresses better (i.e., smaller resulting files) than gzip. Using CamlBZ2 you can read and write compressed "files", where files can be anything offering an in_channel/out_channel abstraction (files, sockets, ...). Also, with CamlBZ2 you can compress and decompress strings in memory using the bzip2 compression algorithm.

CamlGI is a library to enable you to write CGI and FastCGI in OCaml. It is written 100% in OCaml so should run on many platforms. The library supports multiple simultaneous connections and request multiplexing while presenting an easy to use interface.

An image processing library, which provides loading and saving various image formats with an interface for the Caml graphics library. It has also an interface with the freetype library to draw texts using truetype fonts.

A simple module for shell scripting in OCaml.

Camllexer is an enhanced lexer for Caml dialects. The lexer has been extracted from the Camlp4 (> 3.10) lexer, which in turns was reimplemented as a derivative of the lexer from the OCaml compiler.

A library for interfacing Objective Caml with the scripting language Tcl/Tk which is included in the OCaml distribution.

Camomile is a comprehensive Unicode library for OCaml. Camomile provides Unicode character type, UTF-8, UTF-16, UTF-32 strings, conversion to/from about 200 encodings, collation and locale-sensitive case mappings, and more. The library is currently designed for Unicode Standard 3.2.

Cash is a Unix shell that is embedded within Objective Caml. It's a Caml implementation of (an as large as possible subset of) the API of Scsh, the Scheme Shell by Olin Shivers. The Scsh API is designed for writing useful standalone Unix programs and shell scripts (but rather not for interactive command use). It spans a wide range of application, from “script” applications usually handled with perl or sh, to more standard systems applications usually written in C.

A small library to write CGI in Objective Caml.

This module implements compact integer sets, represented as a (custom) list of integer intervals. Usual set operations are provided. The advantage compared to ordered lists is that the actual size may be smaller than the cardinal of a set when many elements are contiguous. Most set operations are linear w.r.t. the size of the structure, not the cardinal of the set.

'Concurrent Cell' is a library for multi-thread programming with CML(Concurrent ML) style synchronous message passing communications. The Threads library, a part of OCaml, realizes the CML style event value, but does not support shared variables like ivar and mvar. This library implements these variables without creating any new thread. This means that ivar and mvar are lightweight and GC target.

A proof assistant.

An exact real arithmetic module for OCaml.

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.

A full-featured charset and string library.

Delimited overloading is a syntax extension to ease the writing of efficient arithmetic expressions in OCaml.

A mutable, circular, doubly linked list library.

Dum is a library for inspecting the runtime representation of arbitrary Objective Caml values. Shared or cyclic data are detected and labelled. This guarantees that printing would always terminate. This makes it possible to print values such as closures, objects or exceptions in depth and without risk.

Dyn is a camlp4 syntax extension for Ocaml that scaffolds injection and projection functions to an from dynamicaly typed values (`dyn`), reifies ocaml type representation in run-time inspectable values (`dtd`), provides camlp4 quotations/antiquotations to work with `dyn`s and `dtd`s. When the `pa_dyn` syntax is loaded it adds a new `type_conv` type processor that can be called by appending `with dyn` after a type definition (e.g. `type t = ... with dyn`) three values are defined: val t_of_dyn : Dyn.Data.t -> t, val dyn_of_t : t -> Dyn.Data.t, val dtd_of_t : Dyn.DTD.t

An Environment Interaction module for Objective Caml. It's useful if you need to create a local copy of the current environment for modification.

The ethread library has modules for read/write locks, barriers, and a simple thread-safe message queue that interacts with Unix.select so a thread can wait for I/O or a message at the same time.

ExtLib is a project aiming at providing a complete - yet small - standard library for the OCaml programming langage. The purpose of this library is to add new functions to OCaml Standard Library modules, to modify some functions in order to get better performances or more safety (tail-recursive) but also to provide new modules which should be useful for the average OCaml programmer.

A library for constraint programming on finite domains.

Frama-C is a suite of tools dedicated to the analysis of the source code of software written in C.

Froc is a library for function reactive programming in OCaml. The interface is similar to FrTime and FlapJax, but (of course) typed, implementing a monad of changeable values. The implementation is data-driven, using the dynamic dependency graphs of Acar et al.'s adaptive functional programming. Froc can be used with ocamljs, and with the included Froc-dom library can be used for web browser programming.

An OCaml interface to the GD graphics library, which is an ANSI C library for the dynamic creation of images. GD creates PNG and JPEG images, among other formats

GenePool is a framework for writing evolutionary optimization algorithms in OCaml. This library is not a complete solution but rather is a generic skeleton which takes care of the plumbing and nuisances of optimization. You provide GenePool with functions that give meaning to fitness and reproduction and after a specified number of generation, GenePool returns an array of the best "genomes" it evolved.

A program (similar to Surf) to draw surfaces from their implicit equations.

A binding to gdome2, the GNU DOM Level 2 implementation.

GraphPS is an Objective Caml module that allows generating PostScript graphic. Its interface is almost identical to that of the Graphics module of the distribution, so that it is easy to switch.

A pure OCaml library for performing calculations based on the Gregorian calendar.

HashSet is a hashed set library for Objective Caml. Buckets are ordered and the first element of a bucket is kept in a separate array, with occupation controlled by a bitvector.

HDCaml provides a framework for describing hardware structures in OCaml. Given a functional hardware description, HDCaml will produce a Verilog netlist for verification and implementation. HDCaml also has decent PSL support for assertion based verification.

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

Heaps, imperative and functional implementations.

HostIP is an OCaml module for looking up geolocation data from IP addresses. It uses the community HostIP project.

A simple tactical theorem prover for higher-order logic.

An ini file parser, in case you ever need to parse one of those little buggers.

"io" is an IO combinator library for safe I/O over strings and channels, in the style of "picklers" which can then be used with various backends to safely load and save data. Currently available backends include : human readable ASCII, binary and compressed binary. A type-independent command can convert between different representations. The representation for records and sum types is upwards compatible. Note that sharing and circular structures are not supported.

IoXML allows defining XML parsers and pretty-printers directly from data type definitions.

Jane Street's alternative to the standard library.

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

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

Lablgtk-extras is a collection of libraries and modules useful when developing OCaml/LablGtk2 applications.

LablGtkSourceView are the OCaml bindings for GtkSourceView, a GTK widget which extends the standrd GTK text widgets implementing syntax highlighting, automatic indentation, and other typical features of source editors. Using LablGtkSourceView you can instantiate and use GtkSourceView widgets in OCaml programs which use GTK through the LablGtk interface.

This OCaml-library interfaces the BLAS-library (Basic Linear Algebra Subroutines) and LAPACK-library (Linear Algebra routines), which are written in FORTRAN.

LEGO Mindstorm® is a versatile robotic construction kit. The central component is the programmable NXT brick to which one can connect up to three motors and various sensors. The brick can run programs directly uploaded to it or can be controlled via bluethooth or USB. This library allows you to communicate with — and drive — your NXT brick from OCaml programs through a bluetooth connection. The full LEGO® communication protocol (including all "direct commands") is supported. This library has been tested on Linux, Windows (without the fantom drivers installed) and Mac OSX.

Liberator is the unix guru's cli to the Freenet network, inserting and requesting easily and efficiently.

A wrapper for the Objective Caml Hashtbl module that uses a Linked List to preserve the order in which the hash elements are added. It's similar in purpose to the Tie::IxHash module for Perl.

A logger module for Objective Caml.

Lpd is a Line Printer Daemon (LPD) server library written entirely in OCaml. It allows to define your own actions for LPD events. An example of a spooler that prints jobs on win32 machines (through GSPRINT) is provided.

Lwt is a library for cooperative threads in OCaml. It is using monadic style, which makes it really easy to use. With respect to preemptive threads, cooperative threads are not using a scheduler to distribute processor time between threads. Each thread must instead tell other threads that it wants them to continue. An uncooperative thread will keep other threads blocked until it has completed its work.

Macaque (Macros for Caml Queries) is a DSL for OCaml, wich produce SQL requests from a comprehension syntax. Macaque can build queries by from simpler components, using phantom types used to ensure safety.

Mathlib is a collection of hopefully-useful functions for working with floats, Complex numbers, and random numbers. It has the basic math functions added to the C99, trigonometric functions for complex numbers, the Mersenne Twister random number generator, and modules for generating random numbers in a variety of distributions.

OCaml interface to various mesh generators, in particular triangle.

A library to produce PostScript documents.

An extended precision computation library (integers, rationals, floats) in OCaml.

An Ocaml interface to MetaPost, a powerful software to draw pictures to be embedded in LaTeX documents.

A set of OCaml bindings for the Apache API, allowing you to run CGI scripts written in OCaml directly inside the Apache webserver.

A library containing functions to read or write mp3 tags.

OCaml bindings to the NLopt nonlinear optimization library. The wrapper code implements an almost complete NLopt API (the only exception are vector-valued constraints).

O'Browser is an implementation of the OCaml virtual machine in JavaScript, designed to run in web browsers. It features a runtime library compatible with OCaml's standard one (including OOP and concurrent threads) and bindings of some JavaScript functions to manipulate the DOM primitives.

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.

This is a proper version of a SOAP client for OCaml, which uses CDuce (http://www.cduce.org/) to parse WSDL + XML Schema interface descriptions, turning them into SOAP client stubs.

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

OCaml-Reins is a data structure library for O'Caml that includes cursor based iterators, a collection of functors to minimize client-side boilerplate, a powerful on-line benchmarking system and Quickcheck style testing infrastructure.

Batteries Included is a candidate standard development platform for OCaml.

This library can read and write CSV files, including all extensions used by Excel - eg. quotes, newlines, 8 bit characters in fields, "0 etc. The library comes with a handy command line tool called csvtool for handling CSV files from shell scripts.

OCaml Curses is a project to provide curses / ncurses bindings for the Objective Caml language. It was formally known as Text Mode Kit (TMK), but the TMK part of the project is not supported any more, and instead we are just concentrating on providing reliable OCaml curses bindings.

Another print anything module.

OCaml port of Iteratees (safe, practical, declarative input processing, by Oleg Kiselyov) to OCaml.

An implementation of the XML-RPC protocol.

Bindings to libarchive, a C library for reading and writing tar, cpio, zip, ISO, and other archive formats.

A small module to benchmark running times of code. It supersedes an earlier version by Doug Bagley.

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/

Thin bindings to various low-level system APIs which are not covered by Unix module.

A random number generator compatible with standard library Random module (pre OCaml 3.12). It contains C code to speed up generation and a function to skip a lot of numbers at once. Benchmarks show a 3 fold increase in speed for generating random numbers.

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

OCaml bindings for the lzma library.

A package for Objective Caml that provides access to MySQL databases.

An OCaml interface for Open Flash Chart 2.

OCaml-RDF is an OCaml library to manipulate RDF graphs.

OCaml-safepass is a library offering facilities for the safe storage of user passwords. By "safe" we mean that passwords are salted and hashed using the Bcrypt algorithm. Salting prevents rainbow-table based attacks, whereas hashing by a very time-consuming algorithm such as Bcrypt renders brute-force password cracking impractical.

OCaml-Win32 is a set of OCaml wrappers for the Win32 API. You can use this library to write true Win32 GUI applications in OCaml. A small sample application is provided.

This library implements the xdg-basedir specification. It helps to define standard locations for configuration, cache and data files in the user directory and on the system. It is a straightforward implementation on UNIX platform and try to apply consistent policies with regard to Windows directories.

ocaml-xmlr provides bindings for libxml's xmlreader.

A database independent layer patterned upon Perl DBI.

OcamlFd is an extension library for the OCaml language, providing miscellaneous utility functions involving UNIX file descriptors.

A graph library. Provides several graph data structures and several graph algorithms. Algorithms are written independently of the graph data structure (using functors).

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.

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.

Automated compilation of complex OCAML-projects.

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.

Acces to databases through ODBC drivers.

OCamlODE is a set of Objective CAML bindings to the Open Dynamics Engine (ODE). It comes with a very simple demonstration game.

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.

An OCaml binding that allows the manipulation of Smartcards in OCaml, both in Linux, through the C library PCSC-Lite provided by M.U.S.C.L.E. and in Windows through Winscard.dll.

An OCaml interface to the GNU libplot library.

OCaml-RSS is an OCaml library providing functions to parse and print RSS 2.0 files.

OCamlScripting is an implementation of the Java JSR223 Scripting API (this API is defined by the javax.script package) for the Objective Caml language. It thus provides a script engine that allows execution of Objective Caml code snippets in a Java application.

OCaml interface to the Simple DirectMedia Layer library. SDL is used for example by 3D games under Linux.

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.

A literate programming tool for Objective Caml.

Ochra is a syntax extension for OCaml, extending the language with explicit support for programming using an Object-Oriented Reference Attributed Grammar (RAG) formalism.

OCI8 bindings for OCaml.

Ocsigen is a Web server, with a programming framework providing a new way to create dynamic Web sites using Objective Caml. Its goal is to offer an alternative to Apache/PHP, based on cutting-edge technologies coming from research in programming languages.

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.

A generator which performs some controls on the collected information. For example: all values are commented, all types are commented, all exceptions have a version tag, ... All the possible controls are turned on/off with command line options.

Generation of html documentation with frames.

An OCamldoc generator which can be used to analyze OCaml files and use @todo tags to generate a TODO list.

OOowrite lets you write OpenOffice or StarOffice .sxw files from OCaml programs.

This library implements an OCaml client interface for an Oracle database. The library is built on top of the OCCI C++ interface available in Oracle 10g. It is efficient and suitable for processing large volumes of data.

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.

Ostap is an OCaml module to provide a set of parser combinators. The name of this library originates from Ostap Bender --- the central character of Ilya Ilf and Eugene Petrov's comedy "The Twelve Chairs". Bender is generally referred to as "The Great Combinator" since the word "combinator" in Russian also means "a swindler", "a sly man" etc. Additionally to the common set of parser combinators Ostap provides a camlp4 syntax extension pa_ostap.cmo to embed grammar expressions written in BNF-like style into OCaml code. Another feature of pa_ostap is that it allows to consider streams as objects and so makes integration of lexers and parsers simpler. Please have a look at the documentation for details.

This project makes use of the Ocaml release 3.10 macro system to add break and continue statements to for and while loops. The macros implement these statements as exceptions. Since the introduction of the two try/with blocks corresponding (each) to the (separate) break and continue exceptions includes some overhead at run time, the macro adds these try/with blocks sparingly... only if the programmer uses the corresponding statement. For example, the continue statements adds the most overhead since it causes a try/with block to be inserted within a loop. However, code that contains no continue statement will be unaffected by the macro.

Camlp4 extension for monadic expressions in OCaml.

A camlp4 extension enabling backward declarations. The "where" keyword, available in the revised syntax, and one of the truly missed Caml-light friends, is back.

Parmap is a minimalistic library allowing to exploit multicore architecture for OCaml programs with minimal modifications.

Efficient sets and maps over integers, from a paper by Chris Okasaki.

Perl compatibility regular expressions for OCaml.

Interface for calling Perl code from OCaml.

A persistent library for Ocaml. PersiL could help you to handle persistent data in your application (data which survive the end of the program).

Pfff is mainly an OCaml API to write static analysis, dynamic analysis, code visualizations, code navigations, or style-preserving source-to-source transformations such as refactorings on source code.

PG'OCaml is a type-safe, simple interface to PostgreSQL from OCaml. It lets you embed SQL statements directly into OCaml code.

Ocaml language bindings for plplot plotting library.

OCaml/Python interface.

A library, entirely written in OCaml, for manipulation of regular expressions and string searching.

Regexp/OCaml provides convenient syntax sugar for regular expression match for strings using PCRE/OCaml library.

Library for automatically resizing contiguous memory (arrays and strings).

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

A LablGTK2 wrapper for Scintilla source code editing widget.

A high-level combinatorial dataflow programming library based upon destructive lazy streams.

Library for serializing OCaml values to and from S-expressions.

This project contains an OCaml re-implementation of some popular utilities like texexpand and delatex that were commonplace in the late 1990’s on all TeX/LaTeX user machines.

Ulex is a lexer generator for Unicode and OCaml.

An Ocaml implementation of extensible arrays. The implementation is functional, based on balanced trees (and on the code for Set and Map).

Weblogs is an OCaml module for importing weblogs from Apache or IIS web servers.

The xapi toolstack, which provides the core Citrix Xenserver's functionalities, is a set of libraries and programs written in OCaml. It is approximately 200k lines of code developed from early 2006. Within Citrix, more than 40 people have already contributed to its source code.

XmlRpc-Light is an XmlRpc client written in OCaml. It requires Xml-Light and Ocamlnet.

XmlRPCServer is a server side implementation for the XmlRPC package developed by Shawn Wagner. This package provides methods to transform between OCaml data-types and their XmlRPC representation, and visa versa. In addition it provide the client side functionality which enables OCaml clients to call servers written in other languages using XmlRPC. However the current version of the package does not support writing the server side in OCaml, unless you do most of the work yourself.

This package implements the XPath recommendation; XPath is a simple query language for XML. A compact XPath expression can perform a relatively complex search on the document tree. XPath is used by XLink and XSLT. The package is modularized and functorial: the evaluator is a functor taking as argument an implementation of the XPath Data Model as defined in the recommendation. The package include a lightweight implementation, build from the Pxp document tree. A future version will include a Data Model implementation working directly on this document tree.

An unfunctorized version of Set and Map.

Xtmpl is a small XML templating library for OCaml.

The Zarith library implements arithmetic and logical operations over arbitrary-precision integers. It uses GMP to efficiently implement arithmetic over big integers. Small integers are represented as Caml unboxed integers, for speed and space economy.