It is unclear to newcomers to the ecosystem what is the canonically preferred way to structure and manage building small to medium sized OCaml projects. I understand the basics of `ocamlc`, &amp;c.--they mirror conventional UNIX C compilers enough to seem straightforward. But, above the level of one-off compilation of individual files, it is unclear how best to manage compilation simply and cleanly. The issue is not searching for potential tools, but seeing one or a few Right (enough) Ways--as validated by the experience of the community--for structuring and building standard OCaml projects.

My model use case is a modest but nontrivial project, of pure OCaml or OCaml plus a C dependency. Such a project:

1. contains a number of source files
2. links to a number of standard libraries
3. links to one or more 3rd party libraries
4. optionally includes a C library and OCaml wrapper as a subproject (though this could also be managed separately and included as a 3rd party library, as in (3))

Several alternative tools stand out:

- Custom Makefiles seem to be the common standard in most open source OCaml packages, but appear frustratingly verbose and complex--even more so than for modest C/C++ projects. Worse, many even seemingly simple OCaml libraries layer autoconf/automake on top for even greater complexity.
- [ocamlbuild](https://ocaml.org/learn/tutorials/ocamlbuild/) appears to offer a modern, streamlined mechanism for automating builds with minimal configuration, but it is not well documented for newcomers, nor represented by example in the introductory materials in the OCaml ecosystem, nor visibly used by any of the various published OCaml projects which I have browsed for inspiration.
- [OASIS](http://oasis.forge.ocamlcore.org/) seems to be a layer of convention and library code atop other build systems to support building a package manager and library, like Cabal.

(I have also seen [OMake](http://omake.metaprl.org/), which appears to be a self-styled &quot;`make++`&quot; which also includes a suite of standard rules for common languages, including OCaml, and [ocaml-make](http://ocaml.info/home/ocaml_sources.html) n&#233;e OCamlMakefile, providing a template of standard rules for GNU `make`.)

Are any of these a preferred, modern way of managing OCaml builds?

How are project files best structured?

How are 3rd party library dependencies included and managed? Is it preferred to install them at the system level, or is there a standard and straightforward way of managing them locally to a project? I would much prefer a model in which projects remain as self-contained as possible.

All Ocamlbuild Solutions on Gang of Coders

Total of 1 Ocamlbuild Solutions

What is the preferred way to structure and build OCaml projects?