[Caml-list] Attn: Development Editor, Latest OCaml Weekly News

Alan Schmitt
2025-10-07T12:22:56Z

[-- Attachment #1: Type: text/plain, Size: 33789 bytes --]

Hello

Here is the latest OCaml Weekly News, for the week of September 30 to
October 07, 2025.

Table of Contents
─────────────────

moonpool 0.9, moonpool-lwt 0.9
First release candidate for OCaml 5.4.0
Announcing the OCaml Zulip at ocaml.zulipchat.com
An impressive macrobenchmark for eio
nim-ocaml
Call for Contributions: BOB 2026 (Berlin, March 13 - Deadline Nov 17)
ocp-indent 1.9.0
Sketch.sh now supports OCaml 5.3.0
OUPS meetup october 2025
New releases of Merlin (5.6) and OCaml-LSP (1.24.0)
Other OCaml News
Old CWN

moonpool 0.9, moonpool-lwt 0.9
══════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-moonpool-0-9-moonpool-lwt-0-9/17337/1>

Simon Cruanes announced
───────────────────────

Hello camels,

I’m happy to announce the release of [moonpool 0.9] and moonpool-lwt
0.9. Moonpool is a concurrency and parallelism library that provides
lightweight fibers and a concept of `Runner.t' that they can be
dispatched on. Multiple runners can co-exist inside a program.

This release is a fairly large one. First, Moonpool now requires OCaml
>= 5.0 (no more 4.xx compat), which removes the need for a
preprocessor and makes `await' generally available on every
`Runner.t'. Some sub-libraries are now deprecated (`moonpool-io',
`moonpool.sync' in favor of picos, etc.).

The biggest improvement is `moonpool-lwt'. It now wraps `Lwt_main.run'
and turns it into a `Moonpool.Runner.t', meaning that `Lwt', `Lwt_io',
`Lwt_unix', and all the libraries built on top can now directly be
used from Moonpool. `Lwt' promises can be turned into moonpool futures
and conversely; fibers can be spawned in the `Lwt_engine' loop from
any thread (to perform IO and call lwt libraries) and be awaited from
other threads, too.

Documentation: <https://c-cube.github.io/moonpool/moonpool/index.html>
,
<https://c-cube.github.io/moonpool/moonpool-lwt/Moonpool_lwt/index.html>

[moonpool 0.9] <https://github.com/c-cube/moonpool/releases/tag/v0.9>

Example echo server
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

┌────
│ module M_lwt = Moonpool_lwt
│
│ let ( let@ ) = ( @@ )
│ let str_of_sockaddr = function
│ | Unix.ADDR_UNIX s -> s
│ | Unix.ADDR_INET (addr, port) ->
│ Printf.sprintf "%s:%d" (Unix.string_of_inet_addr addr) port
│
│
│ let main ~port () : unit =
│ (* never resolved *)
│ let lwt_fut, _lwt_prom = Lwt.wait () in
│
│ let handle_client client_addr (ic, oc) : _ Lwt.t =
│ (* spawn a new fiber in the lwt thread *)
│ let@ () = M_lwt.spawn_lwt in
│ Printf.printf "got new client on %s\n%!" (str_of_sockaddr client_addr);
│
│ let buf = Bytes.create 1024 in
│ let continue = ref true in
│ while !continue do
│ let n = Lwt_io.read_into ic buf 0 (Bytes.length buf) |> M_lwt.await_lwt in
│ if n = 0 then
│ continue := false
│ else (
│ Lwt_io.write_from_exactly oc buf 0 n |> M_lwt.await_lwt;
│ Lwt_io.flush oc |> M_lwt.await_lwt;
│ )
│ done;
│ Printf.printf "done with client on %s\n%!" (str_of_sockaddr client_addr);
│ in
│
│ Printf.printf "listening on port=%d\n%!" port;
│ let addr = Unix.ADDR_INET (Unix.inet_addr_any, port) in
│ let _server =
│ Lwt_io.establish_server_with_client_address addr handle_client
│ |> M_lwt.await_lwt
│ in
│
│ M_lwt.await_lwt lwt_fut (* never returns *)
│
│ let () =
│ let port = ref 1234 in
│ let opts =
│ [
│ "-p", Arg.Set_int port, " port";
│ ]
│ |> Arg.align
│ in
│ Arg.parse opts ignore "echo server";
│
│ M_lwt.lwt_main @@ fun _ -> main ~port:!port ()
└────

Run it as `echo_server -p 1234' and use `nc localhost 1234' to
connect. It will echo lines sent to it.

We can reuse `Lwt_io.establish_server_with_client_address' just fine,
and use direct style to implement the client handler inside a single
`Moonpool' fiber (via `Moonpool_lwt.spawn_lwt' that runs its argument
in the lwt event loop).

Small server with a thread pool for compute
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

a variation on the previous one, with a thread pool on which CPU bound
tasks can be run:

┌────
│ module M_lwt = Moonpool_lwt
│
│ let ( let@ ) = ( @@ )
│ let str_of_sockaddr = function
│ | Unix.ADDR_UNIX s -> s
│ | Unix.ADDR_INET (addr, port) ->
│ Printf.sprintf "%s:%d" (Unix.string_of_inet_addr addr) port
│
│ (* don't do this at home *)
│ let rec fib n =
│ if n <= 2 then 1 else fib (n-1) + fib (n-2)
│
│ let main ~port ~tpool () : unit =
│ (* never resolved *)
│ let lwt_fut, _lwt_prom = Lwt.wait () in
│
│ let handle_client client_addr (ic, oc) : _ Lwt.t =
│ (* spawn a new fiber in the lwt thread *)
│ let@ () = M_lwt.spawn_lwt in
│ Printf.printf "got new client on %s\n%!" (str_of_sockaddr client_addr);
│
│ let continue = ref true in
│ while !continue do
│ match Lwt_io.read_line ic |> M_lwt.await_lwt with
│ | exception End_of_file -> continue := false
│ | line ->
│ let input = int_of_string @@ String.trim line in
│ (* run fib(input) in the thread pool and suspend until
│ it's done *)
│ let fib_input =
│ Moonpool.Fut.spawn ~on:tpool (fun () -> fib input)
│ |> Moonpool.Fut.await
│ in
│
│ Lwt_io.write oc (Printf.sprintf "%d\n" fib_input)
│ |> M_lwt.await_lwt;
│ Lwt_io.flush oc |> M_lwt.await_lwt;
│ done;
│
│ Printf.printf "done with client on %s\n%!" (str_of_sockaddr client_addr);
│ in
│
│ Printf.printf "listening on port=%d\n%!" port;
│ let addr = Unix.ADDR_INET (Unix.inet_addr_any, port) in
│ let _server =
│ Lwt_io.establish_server_with_client_address addr handle_client
│ |> M_lwt.await_lwt
│ in
│
│ M_lwt.await_lwt lwt_fut (* never returns *)
│
│ let () =
│ let port = ref 1234 in
│ let j = ref 8 in
│ let opts =
│ [
│ "-j", Arg.Set_int j, " thread pool size";
│ "-p", Arg.Set_int port, " port";
│ ]
│ |> Arg.align
│ in
│ Arg.parse opts ignore "echo server";
│
│ let@ tpool = Moonpool.Ws_pool.with_ ~num_threads:!j () in
│ M_lwt.lwt_main @@ fun _ -> main ~port:!port ~tpool ()
└────

Note how the computation is done by starting a task in the `tpool'
argument (a moonpool `Runner.t' provided to the main, by default a
work stealing pool of 8 threads that can be set via `-j <number of
threads>') and then `await'-ed from the lwt handler. While the
computation is running, the lwt client handler is suspended and
doesn’t prevent other clients from making progress.

To test this one, use `nc localhost 1234' and write (small) integers
to get `fib(n)' computed. To see it work in parallel, open `top' or
`htop' and run:

┌────
│ for i in `seq 1 200`; do nc localhost 1234 <<< '35' & done
└────

First release candidate for OCaml 5.4.0
═══════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/first-release-candidate-for-ocaml-5-4-0/17338/1>

octachron announced
───────────────────

The release of OCaml 5.4.0 is imminent.

As a final step, we are publishing a release candidate to check that
everything is in order before the release in the upcoming week.

If you find any bugs, please report them on the [OCaml's issue
tracker].

Compared to the second beta, this release candidate only contains a
fix in the TSAN mode, and one metadata fix in the changelog
itself. The full change log for OCaml 5.4.0 is available on [GitHub].

Happy hacking, Florian Angeletti for the OCaml team.

[OCaml's issue tracker] <https://github.com/ocaml/ocaml/issues>

[GitHub] <https://github.com/ocaml/ocaml/blob/5.4/Changes>

Installation instructions
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

The base compiler can be installed as an opam switch with the
following commands on opam 2.1 and later:

opam update opam switch create 5.4.0~rc1

The source code for the release candidate is also directly available
on:

• GitHub: <https://github.com/ocaml/ocaml/archive/5.4.0-rc1.tar.gz>
• OCaml archives at Inria:
<https://caml.inria.fr/pub/distrib/ocaml-5.4/ocaml-5.4.0~rc1.tar.gz>

Fine-tuned compiler configuration
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

If you want to tweak the configuration of the compiler, you can switch
to the option variant with:

┌────
│ opam update
│ opam switch create <switch_name> ocaml-variants.5.4.0~rc1+options <option_list>
└────

where `<option_list>' is a space-separated list of `ocaml-option-*'
packages. For instance, for a `flambda' and `no-flat-float-array'
switch:

┌────
│ opam switch create 5.4.0~rc1+flambda+nffa ocaml-variants.5.4.0~rc1+options ocaml-option-flambda ocaml-option-no-flat-float-array
└────

All available options can be listed with `opam search ocaml-option'.

Announcing the OCaml Zulip at ocaml.zulipchat.com
═════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/announcing-the-ocaml-zulip-at-ocaml-zulipchat-com/17339/1>

ancolie announced
─────────────────

Dear OCaml community,

There has been a recent renewed interest in maintaining an open,
organized and synchronous communication channel, and the OCaml Zulip
has been revived. It is freely readable without an account at
[ocaml.zulipchat.org], and can be accessed through various means of
authentication, including Github accounts.

On Zulip, we have full access to our data at all time, and should the
company change its policy, the data can be retrieved and the current
version of Zulip server is self-hostable. In the meantime, we have
been graciously offered sponsorship as an open community and can enjoy
all features of the platform for free, and we thank Zulip for that.

The platform can be accessed either on the web (one tab per server),
or on the desktop and mobile client, which allow for managing multiple
organizations.

Talking about multiple organizations, there are already many OCaml,
programming languages and verification related Zulip servers, such as
[Rocq], [Types], [Why3], [Catala], [Bytecode alliance], [Owi] or
[Aeneas]. Check-out the full list of [open to the public communities]
for more.

Finally, we would like to emphasize that any governance team or
project is welcome to host their discussions on the Zulip, where a
channel can be created and admin rights granted.

Cheers!

PS: For anyone already on the Zulip, as part of this effort, the URL
was migrated from `caml.zulipchat.org' to `ocaml.zulipchat.org' and
you may have to remove the server and login again.

[ocaml.zulipchat.org] <https://ocaml.zulipchat.org>

[Rocq] <https://rocq-prover.zulipchat.com>

[Types] <https://typ.zulipchat.com>

[Why3] <https://why3.zulipchat.com>

[Catala] <https://zulip.catala-lang.org/>

[Bytecode alliance] <https://bytecodealliance.zulipchat.com>

[Owi] <https://owi.zulipchat.com>

[Aeneas] <https://aeneas-verif.zulipchat.com/>

[open to the public communities] <https://zulip.com/communities/>

An impressive macrobenchmark for eio
════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/an-impressive-macrobenchmark-for-eio/17344/1>

conroj said
───────────

While wandering around the web I came across a link to a [slide deck]
by our own @kayceesrk. On slide #35 is a macrobenchmark showing an
EIO-based network server, and its throughput is pretty favorable
compared to the Rust implementation’s.

Taking this at face value, it seems like quite an achievement - not
only because GC is (supposedly) a handicap for OCaml, but also because
this seems like a major improvement over a [similar benchmark] from
2022. I couldn’t find links to deeper discussion of these results, so
I thought I would ask some of the obvious follow-up questions:

• Is OCaml’s tail latency on par with Rust’s in these scenarios?
• Are both the “OCaml eio” and “Rust Hyper” results using similar
kernel capabilities, e.g. `io_uring'? (The slide seems to suggest
so, but just confirming.)
• Do these results generalize to different levels of concurrency,
request/response sizes, etc?

Either way, kudos for raising OCaml’s profile as a platform for
scalable computing!

[slide deck] <https://kcsrk.info/slides/Evolution_Ashoka_2025.pdf>

[similar benchmark]
<https://tarides.com/blog/2022-12-27-love-rust-then-ocaml-s-new-eio-library-is-for-you/>

Anil Madhavapeddy replied
─────────────────────────

They both used io_uring, yes. The OCaml bindings are at
<https://github.com/ocaml-multicore/ocaml-uring> ; but note that there
are several levels of io_uring usage possible depending on your
tolerance for ranges of Linux kernel support (I’m just adding
zero-copy transmit support at the moment for a project involving a
petabyte of data).

OCaml’s tail latency will be worse than Rust’s due to having a GC, but
not terribly so. As for generalization, those tests were run on a
pre-5.0 version of OCaml, so the whole test suite would have to be
rebased against the released versions. A good and useful exercise if
someone would like to have a go at it!

Thomas Leonard also replied
───────────────────────────

I think the benchmarks are from
<https://github.com/ocaml-multicore/retro-httpaf-bench>

I don’t think the Rust ones are using uring, but I’m not sure. I
suspect that all the non-OCaml ones could do with a fan of that
language optimising them a bit.

In my experience, whether the Rust or Eio version gets better
throughput depends on e.g. the number of connections, and tail latency
was always better with Rust.

But the basic result is that OCaml is competitive with Rust here.

nim-ocaml
═════════

Archive: <https://discuss.ocaml.org/t/ann-nim-ocaml/17346/1>

Florent Monnier announced
─────────────────────────

I read a paper maybe not this one, but it seems it talks about the
same thing [https://arxiv.org/html/2506.04657v1]. At the beginning I
thought it's about the new programming language, but then chatgpt
explained me that in fact it's a small game with stones. We put a
given number of stones in the middle, and each player can take 1, 2 or
3 stones from the stack. There are two variants of the game, the one
that only has one stone in front of him at the end wins or not.

So I tryed to make a `nim-ocaml' to play against its `Random.state',
here below:
┌────
│ let () =
│ Random.self_init () ;
│ let n = 13 + (Random.int 23) in
│ let _n = ref n in
│ let run = ref true in
│ while !run do
│ Printf.printf "%d\n" !_n;
│ if !_n <= 1 then run := false ;
│ let line = read_line () in
│ begin
│ try
│ let d = int_of_string line in
│ _n := !_n - d ;
│ with _ ->
│ Printf.printf "please input an integer number\n%!";
│ end;
│ let b = Random.int 2 + Random.int 3 in
│ Printf.printf "b played: %d\n" b;
│ _n := !_n - b ;
│ done;
│ Printf.printf "done!\n" ;
└────
┌────
│ $ \ocaml nim.ml
└────
Or later:
┌────
│ $ wget http://decapode314.free.fr/ocaml2/nim/nim.ml
└────
┌────
│ $ \ocaml nim.ml
│ 23
│ 3
│ b played: 3
│ 17
│ 7
│ b played: 0
│ 10
│ 3
│ b played: 2
│ 5
│ 2
│ b played: 2
│ 1
│ 0
│ b played: 0
│ done!
└────
Another version to play against your collegue at the pause:
┌────
│ $ wget http://decapode314.free.fr/ocaml2/nim/.gil/nim.ml.0
└────

[https://arxiv.org/html/2506.04657v1]
<https://arxiv.org/html/2506.04657v1>

Call for Contributions: BOB 2026 (Berlin, March 13 - Deadline Nov 17)
═════════════════════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/call-for-contributions-bob-2026-berlin-march-13-deadline-nov-17/17348/1>

Michael Sperber announced
─────────────────────────

OCaml contributions are spot-on for BOB - send us some!

*BOB Conference 2026 - Call for Contributions*

“What happens when we use what’s best for a change?”
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

• <https://bobkonf.de/2026/cfc.html>
• Berlin, Mar 13
• Deadline: November 17, 2025

Looking for Speakers
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

You are actively engaged in advanced software engineering methods,
solve ambitious problem with software and are open to cutting-edge
innovation? Attend this conference, meet people that share your goals,
and get to know the best software tools and technologies available
today. We strive to offer a day full of new experiences and
impressions that you can use to immediately improve your daily life as
a software developer.

If you share our vision and want to contribute, submit a proposal for
a talk or tutorial!

*NOTE*: The conference fee will be waived for presenters. Travel
expenses will not be covered (for exceptions see “Speaker Grants”).

Topics
╌╌╌╌╌╌

We are looking for talks about best-of-breed software technology,
e.g.:

• functional programming
• persistent data structures and databases
• event-based modelling and architecture
• “fancy types” (dependent types, gradual typing, linear types, …)
• formal methods for correctness and robustness
• abstractions for concurrency and parallelism
• metaprogramming
• probabilistic programming
• math and programming
• controlled side effects
• program synthesis
• AI beyond vibecoding and chatbots
• linked data
• symbolic AI
• next-generation IDEs
• effective abstractions for data analytics
• … everything really that isn’t mainstream, but you think should be
• … including rough ideas that are worth discussing.

Presenters should provide the audience with information that is
practically useful for software developers.

Challenges
╌╌╌╌╌╌╌╌╌╌

Furthermore, we seek contributions on successful approaches for
solving hard problems, for example:

• bias in machine-learning systems
• digital transformation in difficult settings
• accessibility
• systems with critical reliability requirements
• ecologically sustainable software development

*We’re especially interested in experience reports.*

Other topics are also relevant, e.g.:

• introductory talks on technical background
• overviews of a given field
• demos and how-tos

Requirements
╌╌╌╌╌╌╌╌╌╌╌╌

We accept proposals for presentations of 45 minutes (40 minutes talk +
5 minutes questions), as well as 90 minute tutorials for
beginners. The language of presentation should be either English or
German.

Your proposal should include (in your presentation language of
choice):

• An abstract of max. 1500 characters.
• A short bio/cv
• Contact information (including at least email address)
• A list of 3-5 concrete ideas of how your work can be applied in a
developer’s daily life
• additional material (websites, blogs, slides, videos of past
presentations, …)

[Submit here]

[Submit here] <https://pretalx.com/bob-2026/submit/>

Organisation
╌╌╌╌╌╌╌╌╌╌╌╌

• Direct questions to `konferenz at bobkonf dot de'
• Proposal deadline: *November 17, 2025*
• Notification: December 5, 2025
• Program: December 12, 2025

Shepherding
╌╌╌╌╌╌╌╌╌╌╌

The program committee offers shepherding to all speakers. Shepherding
provides speakers assistance with preparing their
sessions. Specifically:

• advice on structure and presentation
• review of talk slides

Speaker Grants
╌╌╌╌╌╌╌╌╌╌╌╌╌╌

BOB has Speaker Grants available to support speakers from groups
under-represented in technology. We specifically seek women speakers,
speakers of color, and speakers who are not able to attend the
conference for financial reasons.

ocp-indent 1.9.0
════════════════

Archive: <https://discuss.ocaml.org/t/ann-ocp-indent-1-9-0/17349/1>

Nathan Rebours announced
────────────────────────

Here at OCamlPro we’re happy to announce the (long awaited) release of
ocp-indent.1.9.0.

The full release notes are available [here] if you want the detailed
version.

1.9.0 contains mostly bug fixes, better and more consistent
indentation of `fun _ ->' and `|>', compatibility with cmdliner.1.3.0
and above (it works with 2.0.0) and a new utility tool:
`ocp-indent-gen-rules' for those of you who would like to try
`ocp-indent' in a `dune fmt' like workflow.

This last bit is documented [here]. This is a feature that some of us
wanted internally at OCamlPro so we decided to ship it with the tool
as an experiment. We’d really like to hear if this fits your
ocp-indent usage so please don’t hesitate to try it out and give us
some feedback.

We’re also interested in hearing how you use ocp-indent in general and
what you expect from it. Reach out if you have any request!

We’ve also updated the repo to fit the more recent development
standards. We migrated the test suite to dune cram tests and
re-enabled them in opam. Hopefully this should make contributing to
ocp-indent a smoother experience!

Also be aware that we’ll do our best to maintain ocp-indent more
actively from now on.

We’d like to thank our external contributors for this release:
@dbuenzli, @nojb, @bcc32 and @Julow.

Happy indenting!

[here] <https://github.com/OCamlPro/ocp-indent/releases/tag/1.9.0>

[here]
<https://github.com/OCamlPro/ocp-indent?tab=readme-ov-file#autoformat-files-with-ocp-indent-in-dune>

Sketch.sh now supports OCaml 5.3.0
══════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-sketch-sh-now-supports-ocaml-5-3-0/17352/1>

Javier Chávarri announced
─────────────────────────

The interactive OCaml sketchbook [sketch.sh] has added support for
OCaml 5.3.0.

[sketch.sh] <https://sketch.sh/>

*Support for 5.3.0*
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

Storing and running sketches using the compiler version 5.3.0 is now
possible, this functionality has been added to the already existing
support for versions 4.06.1 and 4.13.1. This new version brings
support for OCaml 5’s effect handlers and multicore
capabilities. Since sketch.sh runs in the browser using JavaScript via
js_of_ocaml, the multicore capabilities are simulated using
[continuation-passing style].

Here you can see a sketch showcasing effects: [Effects Example -
Sketch.sh].

While support for intermediate versions is technically possible, it
will require adding a mechanism to support choosing the version of the
compiler for the current sketch (see [issue #375]).

[continuation-passing style]
<https://ocsigen.org/js_of_ocaml/latest/manual/effects>

[Effects Example - Sketch.sh]
<https://sketch.sh/s/gyQVWEOw4gRaSk1RzH2BBQ/>

[issue #375] <https://github.com/Sketch-sh/sketch-sh/issues/375>

*Existing sketches and forks*
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

Previously existing sketches remain in their original compiler
version, while newly created sketches will be on 5.3.0 by default. For
now, the only way to "migrate" a sketch to a newer version of the
compiler is by copying its content and pasting it in a new sketch.

Forked sketches inherit the compiler version of the upstream sketch.

*Reporting features and issues*
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

Please [let us know] in case you have a feature request, or if you
encounter any issues or bugs. Also, don't hesitate to reach out via
[Reason Discord] or Discuss DMs if you would like to contribute or
participate in the project in some way. There are a lot of
opportunities to do so, both on the frontend and backend sides.

[let us know] <https://github.com/Sketch-sh/sketch-sh/issues/new>

[Reason Discord] <https://discord.gg/reasonml>

OUPS meetup october 2025
════════════════════════

Archive:
<https://discuss.ocaml.org/t/oups-meetup-october-2025/17353/1>

ancolie announced
─────────────────

The next OUPS meetup will take place on *Monday, 13th of October*
2025. It will start at *6:30pm* at the *4 place Jussieu* in Paris. It
will be in the in the *Esclangon building* (amphi Astier).

Please, *[register on meetup ]* as soon as possible to let us know how
many pizza we should order.

For more details, you may check the [OUPS’ website ].

Moreover, we'd like to announce that the organizing team moved to the
[OCaml Zulip]. Feel free to contact us there if you'd like to suggest
talks.

This time we’ll have the following talks:

*What's the deal with modular implicits ? – Samuel Vivien*

Modular implicits est une extension d'OCaml présentée en
2014 comme une solution à l'absence de type classe en
OCaml. Cependant malgré l'ancienneté de cette proposition
cette fonctionnalité n'est toujours pas disponible dans
OCaml. Nous ferons un tour d'horizon de modular implicits
pour rappeler comment cette fonctionnalité marche, ce qui
as déjà été implémenté dans le compilateur mais aussi ce
qu'il reste à faire ainsi que les problématiques liés au
typage des implicites.

*Flambda2: Abstractions without Cost – Guillaume Bury*

Surprise.

After the talks there will be some pizzas offered by the [OCaml
Software Foundation] and later on we’ll move to a pub nearby as usual.

[register on meetup ]
<https://www.meetup.com/fr-FR/ocaml-paris/events/311402632>

[OUPS’ website ] <https://oups.frama.io>

[OCaml Zulip] <https://ocaml.zulipchat.com>

[OCaml Software Foundation] <https://ocaml-sf.org>

New releases of Merlin (5.6) and OCaml-LSP (1.24.0)
═══════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-new-releases-of-merlin-5-6-and-ocaml-lsp-1-24-0/17354/1>

Xavier Van de Woestyne announced
────────────────────────────────

We are pleased to announce new releases of *Merlin* (`5.6-504' and
`5.6-503') and *OCaml-LSP* (`1.24.0', for `5.4', and `1.23.1')!

This release of *Merlin* offers, firstly, support for OCaml `5.4'. It
improves support for OpenBSD (for `merlin-reader'), improves typing
recovery in the handling of mutual recursion, and adds a new feature
to the protocol: `locate-types'. It works similarly to `locate-type',
except that it allows you to distinguish between several _locatable_
types in an expression like this: `(int, Foo.t) result' enabling the
location of: `int', `Foo.t' and `('a, 'b) result'. In addition, the
Vim client has been fixed for the use of `project-wide-occurrences'.

The release of *OCaml LSP* also mainly concerns support for `5.4' and
several bug fixes.

As with every version upgrade, *we are eager to hear user
feedback*. Try out these new releases on your `5.4' switches and don't
hesitate to report any issues you encounter ([Merlin], [OCaml LSP])!

[Merlin] <https://github.com/ocaml/merlin/issues>

[OCaml LSP] <https://github.com/ocaml/ocaml-lsp/issues>

Merlin Changelog
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

◊ Merlin `5.6-504' (& `5.6-503')

⁃ merlin binary
• Add `locate-types' command (#1951)
⁃ merlin library
• Fix `merlin_reader' for OpenBSD (#1956)
• Improve recovery of mutually recursive definitions (#1962, #1963,
fixes #1953)
• Support for OCaml `5.4' (#1974) (*only for `5.6-504'*)
⁃ vim plugin
• Fix error when `:MerlinOccurrencesProjectWide' fails to gather
code previews (#1970)
⁃ test suite
• Add more short-paths tests cases (#1904)

OCaml LSP Changelog
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

◊ `1.24.0' & `1.23.1'

⁃ features
• Support for OCaml `5.4' (#1559)
⁃ fixes
• Fix hover on method calls not showing the type. (#1553, fixes
#1552)
• Fix error on opening `.mll' files (#1557)
• Ensure compatibility with both yojson 2.0 and 3.0. (#1534)

*Happy Hacking*! The Merlin Team :man_mage: :two_hump_camel:

Other OCaml News
════════════════

>From the ocaml.org blog
───────────────────────

Here are links from many OCaml blogs aggregated at [the ocaml.org
blog].

• [Upcoming OCaml Events]
• [One year at Ahrefs]
• [Attempting overlayfs with macFuse]
• [Mental Check: Reflecting on the OCaml Journey So Far]
• [Ocsigen: A Full OCaml Framework for Websites and Apps]
• [File descriptors as integers considered harmful]
• [Hacking OCaml]
• [File descriptors are not integers]

[the ocaml.org blog] <https://ocaml.org/blog/>

[Upcoming OCaml Events] <https://ocaml.org/events>

[One year at Ahrefs]
<https://tech.ahrefs.com/one-year-at-ahrefs-065167c61542?source=rss----303662d88bae--ocaml>

[Attempting overlayfs with macFuse]
<https://www.tunbury.org/2025/10/06/overlayfs-macFuse/>

[Mental Check: Reflecting on the OCaml Journey So Far]
<https://fearful-odds.rocks/journal/oct-5-entry>

[Ocsigen: A Full OCaml Framework for Websites and Apps]
<https://tarides.com/blog/2025-10-02-ocsigen-a-full-ocaml-framework-for-websites-and-apps>

[File descriptors as integers considered harmful]
<https://www.dra27.uk/blog/platform/2025/10/01/int-file-descriptors-considered-harmful.html>

[Hacking OCaml] <https://www.youtube.com/watch/SV9Vna-Qgo8?version=3>

[File descriptors are not integers]
<https://www.dra27.uk/blog/platform/2025/09/30/file-descriptors-are-not-integers.html>

Old CWN
═══════

If you happen to miss a CWN, you can [send me a message] and I'll mail
it to you, or go take a look at [the archive] or the [RSS feed of the
archives].

If you also wish to receive it every week by mail, you may subscribe
to the [caml-list].

[Alan Schmitt]

[send me a message] <mailto:alan.schmitt@polytechnique.org>

[the archive] <https://alan.petitepomme.net/cwn/>

[RSS feed of the archives] <https://alan.petitepomme.net/cwn/cwn.rss>

[caml-list] <https://sympa.inria.fr/sympa/info/caml-list>

[Alan Schmitt] <https://alan.petitepomme.net/>

[-- Attachment #2: Type: text/html, Size: 62234 bytes --]