OCaml 5.2.0 (13 May 2024) ------------------------ OCaml 5.2.0 is still a somewhat experimental release compared to the OCaml 4.14 branch. Some of the highlights in OCaml 5.2.0 are: - Re-introduced GC compaction - Restored native backend for POWER 64 bits - Thread sanitizer support - New Dynarray module - New -H flag for hidden include directories - Project-wide occurence metadata support for developer tools - Raw identifiers - Local open in type expressions And a lot of incremental changes: - Around 20 new functions in the standard library - Many fixes and improvements in the runtime - Many bug fixes OCaml 5.1.0 (14 September 2023) ------------------------------- OCaml 5.1.0 is still a relatively experimental release compared to the OCaml 4.14 branch. Some of the highlights in OCaml 5.1.0 are: - Many runtime performance regression and memory-leaks fixes (dynlinking, weak arrays, weak hash sets, GC with idle domains, and GC prefetching). - Restored support for native code generation on RISC-V and s390x architectures. - Restored Cygwin port. - Reduced installation size (50% reduction) - Compressed compilation artefacts (.cmi, .cmt, .cmti, .cmo, .cma files) - 19 error message improvements - 14 standard library functions made tail-recursive with Tail-Recursion-Modulo-Cons (TRMC), such as List.append and List.map. - 57 new standard library functions - More examples in the standard library documentation - 42 bug fixes OCaml 5.0.0 (15 December 2022) ------------------------------ OCaml 5.0.0 introduces a completely new runtime environment with support for shared memory parallelism and effect handlers. As a language, OCaml 5 is fully compatible with OCaml 4 down to the performance characteristics of your programs. In other words, any code that works with OCaml 4 should work the same with OCaml 5. The currently known exceptions to this rule are: - the removal of many long-deprecated functions and modules - changes to the internal runtime API - the performance of ephemerons is currently (and temporarily) strongly degraded. OCaml 4.14.0 (28 March 2022) ---------------------------- - Integrated support for "go to definitions" in Merlin. - Standard library: new modules In_channel and Out_channel, many new functions in Seq module, UTF decoding and validation support for strings and bytes. - Runtime optimisation: GC prefetching. Benchmarks show a speedup of around 20% in GC-heavy programs. - Improved error messages in particular for module-level error. - Deprecated functions and modules in preparation for OCaml 5. In particular, the Stream and Genlex modules are now deprecated. - Type variables can be explicitly introduced in value and variant constructor declarations. For instance, ```ocaml val fold: ('acc -> 'elt -> 'acc) -> 'acc -> 'elt list -> 'acc type showable = Show: 'a * ('a -> string) -> showable ``` can now be written as ```ocaml val fold: 'acc 'elt. ('acc -> 'elt -> 'acc) -> 'acc -> 'elt list -> 'acc type showable = Show: 'a. 'a * ('a -> string) -> showable ``` - Tail-call with up to 64 arguments are now guaranteed to be optimized for all architectures. - Experimental tail modulo cons (TMC) transformation OCaml 4.13.0 (24 September 2021) ------------------------------- - Safe points: a multicore prerequisite that ensures that ocamlopt-generated code can always be interrupted. - The best-fit GC allocation policy is now default policy (and many other GCs improvements.) - Named existential type variables in pattern matching: Showable (type a) (x, show : a * (a -> string)). - Improved error messages for functor application and functor types. - Let-punning for monadic let: let* x = x in can be shortened to let* x in. - Module type substitutions SIG with module type T = F(X).S. - Many other quality of life improvements - Many bug fixes OCaml 4.12.0 (24 February 2021) ------------------------------- - Major progress in reducing the difference between the mainline and multicore runtime - A new configuration option ocaml-option-nnpchecker which emits an alarm when the garbage collector finds out-of-heap pointers that could cause a crash in the multicore runtime - Support for macOS/arm64 - Mnemonic names for warnings - Many quality of life improvements - Many bug fixes OCaml 4.11.0 (19 August 2020) ------------------------------ - Statmemprof: a new statistical memory profiler - A new instrumented runtime that logs runtime statistics in a standard format - A native backend for the RISC-V architecture - Improved backtraces that refer to function names - Support for recursive and yet unboxed types - A quoted extension syntax for ppxs. - Many quality of life improvements - Many bug fixes. OCaml 4.10.0 (21 February 2020) ------------------------------- - New best-fit allocator for the major heap - Preliminary runtime work for OCaml multicore - Immutable strings are now enforced at configuration time - User-defined indexing operators for multidimensional arrays - Coming soon: statmemprof, a new statistical memory profiler. - The external API will be released next version. - Various improvements to the manual - More precise exhaustiveness check for GADTs - Many bug fixes OCaml 4.09.1 (18 March 2020) ---------------------------- Bug fixes. OCaml 4.09.0 (18 September 2019) -------------------------------- - New optimisations, in particular for affine functions in matches, for instance: type t = A | B | C let affine = function | A -> 4 | B -> 3 | C -> 2 - The `graphics` library was moved out of the compiler distribution. - The `vmthread` library was removed. - Support for compiler plugins was removed. - Many bug fixes. OCaml 4.08.1 (5 August 2019) ---------------------------- Bug fixes. OCaml 4.08.0 (14 June 2019) --------------------------- - Binding operators (let*, let+, and*, etc). They can be used to streamline monadic code. - `open` now applies to arbitrary module expression in structures and to applicative paths in signatures. - A new notion of (user-defined) "alerts" generalizes the deprecated warning. - New modules in the standard library: Fun, Bool, Int, Option, Result. - A significant number of new functions in Float, including FMA support, and a new Float.Array submodule. - Source highlighting for errors and warnings in batch mode. - Many error messages were improved. - Improved AFL instrumentation for objects and lazy values. OCaml 4.07.1 (4 October 2018) ----------------------------- This release consists mostly of bug fixes. The most salient bugs were - MPR#7820, GPR#1897: a bug in Array.of_seq (new in 4.07) (Thierry Martinez, review by Nicolás Ojeda Bär) - MPR#7815, GPR#1896: crash in the major GC with the first-fit policy (Stephen Dolan and Damien Doligez, report by Joris Giovannangeli) - MPR#7821, GPR#1908: the compiler loads more cmi, which breaks some builds (Jérémie Dimino, review by Gabriel Scherer) - MPR#7833, GPR#1946: typechecking failure (regression) on large GADT matchings (Thomas Refis, report by Jerome Simeon, review by Jacques Garrigue) See the detailed list of fixes at (Changes#4.07.1). OCaml 4.07.0 (10 July 2018): ---------------------------- Some highlights of this release are: - The way the standard library modules are organized internally has changed (GPR#1010, by Jérémie Dimino): 1. the `List` module (for example) is now named `Stdlib__list` 2. a new Stdlib module contains a series of aliases such as `module List = Stdlib__list` 3. the `Stdlib` module is implicitly opened when type-checking OCaml programs (as `Pervasives` previously was), so that `Stdlib.List` can be accessed as just `List`, as before. This should be invisible to most users, although it is possible that some tools show the `Stdlib.` or `Stdlib__` prefixes in messages. (You might want to report these situations as usability bugs.) The change prevents standard library modules from conflicting with end-user filenames (please avoid `stdlib.ml` and the `Stdlib__` prefix); we may introduce new standard library modules in the future with less fear of breaking user code. In particular, `Float` (GPR#1638, by Nicolás Ojeda Bär) and `Seq` (GPR#1002, by Simon Cruanes) modules have now been added to the standard library. - The error messages caused by various typing errors have been improved to be easier to understand, in particular for beginners. (GPR#1505, GPR#1510, by Arthur Charguéreau and Armaël Guéneau) For example, # while 1 do () done;; ^ Error: This expression has type int but an expression was expected of type bool now adds the extra explanation because it is in the condition of a while-loop - Effort has been made to reduce the compilation time of flambda programs, and the size of the produced `.cmx` files when using the -Oclassic optimisation level. (GPR#1401, GPR#1455, GPR#1627, GPR#1665, by Pierre Chambart, Xavier Clerc, Fuyong Quah, and Leo White) - The HTML manual has benefited from various style improvements and should look visually nicer than previous editions. (GPR#1741, GPR#1757, GPR#1767 by Charles Chamberlain and steinuil) The new version of the manual can be consulted at ; see the previous version for comparison at . - Since 4.01, it is possible to select a variant constructor or record field from a sub-module that is not opened in the current scope, if type information is available at the point of use. This now also works for GADT constructors. (GPR#1648, by Thomas Refis and Leo White) - The GC should handle the accumulation of custom blocks in the minor heap better; this solves some memory-usage issues observed by code which allocates a lot of small custom blocks, typically small bigarrays (GPR#1476, by Alain Frsich) See also the detailed list of changes: (Changes#4.07.0). OCaml 4.06.1 (16 Feb 2018): --------------------------- This release consists mostly of bug fixes. The most salient bugs were - An incorrect compilation of pattern-matching in presence of extensible variant constructors (such as exceptions), that had been present for a long time. (GPR#1459, GPR#1538, by Luc Maranget, Thomas Refis and Gabriel Scherer) - An optimization of `not (x = y)` into `x <> y`, introduced in 4.06.0, is incorrect on floating-point numbers in the `nan` case. (GPR#1470, by Leo White) See the detailed list of fixes at (Changes#4.06.1). OCaml 4.06.0 (3 Nov 2017): -------------------------- - Strings (type `string`) are now immutable by default. In-place modification must use the type `bytes` of byte sequences, which is distinct from `string`. This corresponds to the `-safe-string` compile-time option, which was introduced in OCaml 4.02 in 2014, and which is now the default. (GPR#1252, by Damien Doligez) - Object types can now extend a previously-defined object type, as in ``. (GPR#1118, by Runhang Li) - Destructive substitution over module signatures can now express more substitutions, such as `S with type M.t := type-expr` and `S with module M.N := path`. (GPR#792, by Valentin Gatien-Baron) - Users can now define operators that look like array indexing, e.g. `let ( .%() ) = List.nth in [0; 1; 2].%(1)` (GPR#1064, GPR#1392, by Florian Angeletti) - New escape `\u{XXXX}` in string literals, denoting the UTF-8 encoding of the Unicode code point `XXXX`. (GPR#1232, by Daniel Bünzli) - Full Unicode support was added to the Windows runtime system. In particular, file names can now contain Unicode characters. (GPR#153, GPR#1200, GPR#1357, GPR#1362, GPR#1363, GPR#1369, GPR#1398, GPR#1446, GPR#1448, by ygrek and Nicolás Ojeda Bär) - An alternate register allocator based on linear scan can be selected with `ocamlopt -linscan`. It reduces compilation time compared with the default register allocator. (GPR#375, Marcell Fischbach and Benedikt Meurer) - The Num library for arbitrary-precision integer and rational arithmetic is no longer part of the core distribution and can be found as a separate OPAM package. See the detailed list of changes: (Changes#4.06.0). OCaml 4.05.0 (13 Jul 2017): --------------------------- Some highlights include: - Instrumentation support for fuzzing with afl-fuzz. (GPR#504, by Stephen Dolan) - The compilers now accept new `-args/-args0 ` command-line parameters to provide extra command-line arguments in a file. User programs may implement similar options using the new `Expand` constructor of the `Arg` module. (GPR#748, GPR#843, GPR#864, by Bernhard Schommer) - Many functions of the standard library that raise an exception now have an option-returning variable suffixed by `_opt` Typical examples of the new functions include: int_of_string_opt: string -> int option List.nth_opt: 'a list -> int -> 'a option Hashtbl.find_opt : ('a, 'b) t -> 'a -> 'b option (GPR#885, by Alain Frisch) - The security of the runtime system is now hardened by using `secure_getenv` to access environment variables whenever its possible, to avoid unplanned privilege-escalation when running setuid binaries. (GPR#1213, by Damien Doligez) See the detailed list of changes: (Changes#4.05.0).