Dose3 is a framework made of several OCaml libraries for managing distribution packages and their dependencies. Though not tied to any particular distribution, dose3 constitutes a pool of libraries which enable analyzing packages coming from various distributions. Besides basic functionalities for querying and setting package properties, dose3 also implements algorithms for solving more complex problems such as monitoring package evolutions, correct and complete dependency resolution and repository-wide uninstallability checks.

This module implements purely in OCaml a character width function that follows the prototype of POSIX's wcwidth.

Fpath is an OCaml module for handling file system paths with POSIX or Windows conventions. Fpath processes paths without accessing the file system and is independent from any system library.

ppx_bap is the set of blessed ppx rewriters used in BAP projects. It fills the same role as ppx_base or ppx_jane (from which it is derived), but doesn't impose any style requirements and has only the minimal necessary set of rewriters.

This package contains deriving conversion functions to and from yaml for OCaml types.

Logs provides a logging infrastructure for OCaml. Logging is performed on sources whose reporting level can be set independently. Log message report is decoupled from logging and is handled by a reporter.

This package installs a ppx-jane executable, which is a ppx driver including all standard Jane Street ppx rewriters.

Unix-related dependencies for things like system calls and threads. Using these, it hooks the Async_kernel scheduler up to either epoll or select, depending on availability, and manages a thread pool that blocking system calls run in.

Down is an unintrusive user experience upgrade for the ocaml toplevel (REPL).

Simply load the zero dependency down library in the ocaml toplevel and you get line edition, history, session support and identifier completion and documentation with ocp-index.

Add this to your ~/.ocamlinit:

#use "down.top"

You may also need to add this to your ~/.ocamlinit and declare the environment variable OCAML_TOPLEVEL_PATH:

let () =
  try Topdirs.dir_directory (Sys.getenv "OCAML_TOPLEVEL_PATH")
  with Not_found -> ()

OR

let () = String.split_on_char ':' (Sys.getenv "OCAMLPATH")
         |> List.filter (fun x -> Filename.check_suffix x "/site-lib")
         |> List.map (fun x -> x ^ "/toplevel")
         (* remove the line below if you don't want to see the text
            every time you start the toplevel *)
         |> List.map (fun x -> Printf.printf "adding directory %s\n" x; x)
         |> List.iter Topdirs.dir_directory;;

The "findlib" library provides a scheme to manage reusable software components (packages), and includes tools that support this scheme. Packages are collections of OCaml modules for which metainformation can be stored. The packages are kept in the file system hierarchy, but with strict directory structure. The library contains functions to look the directory up that stores a package, to query metainformation about a package, and to retrieve dependency information about multiple packages. There is also a tool that allows the user to enter queries on the command-line. In order to simplify compilation and linkage, there are new frontends of the various OCaml compilers that can directly deal with packages.

This package implements an Ocaml language server implementation.

These libraries provides access to low-level compiler interfaces and the standard higher-level merlin protocol.

This package provides a bundle of useful runtime functions for applications built with MirageOS

OASIS is a tool to integrate a configure, build and install system in your OCaml projects. It helps to create standard entry points in your build system and allows external tools to analyse your project easily.

A comprehensive toolbox for ppx development. It features:

• an OCaml AST / parser / pretty-printer snapshot, to create a full frontend independent of the version of OCaml;

• a library for library for ppx rewriters in general, and type-driven code generators in particular;

• a feature-full driver for OCaml AST transformers;

• a quotation mechanism allowing to write values representing the OCaml AST in the OCaml syntax;

• a generator of open recursion classes from type definitions.

This module provides a set of tools to measure the running times of your functions and to easily compare the results. A statistical test is used to determine whether the results truly differ.

Spawn is a small library exposing only one functionality: spawning sub-process.

It has three main goals:

• provide missing features of Unix.create_process such as providing a working directory,

• provide better errors when a system call fails in the sub-process. For instance if a command is not found, you get a proper Unix.Unix_error exception,

• improve performances by using vfork when available. It is often claimed that nowadays fork is as fast as vfork, however in practice fork takes time proportional to the process memory while vfork is constant time. In application using a lot of memory, vfork can be thousands of times faster than fork.

This package generates JUnit XML reports from ocaml-alcotest test suites.

Ctypes is a library for binding to C libraries using pure OCaml. The primary aim is to make writing C extensions as straightforward as possible. The core of ctypes is a set of combinators for describing the structure of C types -- numeric types, arrays, pointers, structs, unions and functions. You can use these combinators to describe the types of the functions that you want to call, then bind directly to those functions -- all without writing or generating any C!

Uutf is a non-blocking streaming codec to decode and encode the UTF-8, UTF-16, UTF-16LE and UTF-16BE encoding schemes. It can efficiently work character by character without blocking on IO. Decoders perform character position tracking and support newline normalization.

Functions are also provided to fold over the characters of UTF encoded OCaml string values and to directly encode characters in OCaml Buffer.t values.

OCaml is a general purpose industrial-strength programming language with an emphasis on expressiveness and safety. Developed for more than 20 years at Inria it benefits from one of the most advanced type systems and supports functional, imperative and object-oriented styles of programming.

This OCaml library offers a set of combinators for building so-called documents as well as an efficient engine for converting documents to a textual, fixed-width format. The engine takes care of indentation and line breaks, while respecting the constraints imposed by the structure of the document and by the text width.

This ocaml library returns user XDG directories such as XDG_CONFIG_HOME, XDG_STATE_HOME.

This library parses ocaml compiler output and returns it as ocaml values. This library offers no backwards compatibility guarantees.