ocamlopt

ocamlopt [options] files...

ocamlopt is the OCaml native-code compiler. It compiles OCaml source files directly to native machine code, producing significantly faster executables than the bytecode compiler ocamlc. The output is architecture-specific and not portable across platforms.Compilation proceeds in three phases: type-checking and compilation to `.cmx` / `.o` files (`-c`), optional library archiving (`-a`), and linking. Interface files (`.mli`) are compiled to `.cmi` files shared with the bytecode compiler.

-o file

Specify the output filename.

Compile only; suppress the linking phase. Produces `.cmx` and `.o` files.

Build a library (`.cmxa` and `.a` files) from the given object files.

Build a dynamically loadable plugin (`.cmxs` file).

Combine multiple `.cmx` files into a single compilation unit.

Optimization level: `0` disables all optimizations, `3` enables aggressive optimization including unboxing. Default is `1`.

Add dir to the search path for `.cmi` and `.cmx` files.

Add debugging information to enable stack backtraces at runtime.

Keep the assembly code produced during compilation in a `.s` file.

Set the aggressiveness of inlining (default 10; higher means more inlining).

Optimize the produced code for space rather than speed.

Disable bounds checking on array/string accesses and zero-division checks; faster but unsafe.

Generate an object file that can later be included as a sub-module in a `-pack` compilation.

Force all modules contained in libraries to be linked in.

Pipe source files through the given preprocessor command.

Pipe the abstract syntax tree through the given preprocessor.

Enable, disable, or mark as fatal specific compiler warnings.

Turn the specified warnings into errors.

Open the named module before processing each source file.

Do not include the standard library directory in the search path.

Use ccomp as the C linker when building executables.

Link with the given C library.

Pass option to the C compiler and linker.

Print all external commands as they are executed.

Print the version number of the compiler and the location of the standard library.

Print inferred interface to stdout; do not produce object files.

Generate detailed type and location information in `.cmt` and `.cmti` files.

Native-code compilation is slower than bytecode compilation. The resulting executables are platform-specific. Debugging native code is harder than debugging bytecode; ocamldebug does not support native executables (use `-g` and system debuggers such as `gdb`).

The OCaml native-code compiler was developed at INRIA alongside the bytecode compiler as part of the Caml/OCaml project to provide high-performance compilation while retaining the language's type safety guarantees.

ocamlc(1), ocamlfind(1), opam(1), dune(1)