OCaml Weekly News

Hello,

I'm happy to announce the first release of nanoev, yet another event loop abstraction. My goal with it is to have a narrow-waist interface between event loops (for now, select and poll) and various abstractions built directly on top (for now using picos), without tying the event loop abstraction itself to a particular scheduler. The core interface for the event loop is basically:

type t

val wakeup_from_outside : t -> unit

val step : t -> unit
(** Run one step of the event loop until something happens *)

val close : t -> Unix.file_descr -> unit
(** Close the file descriptor and clean it up *)

val max_fds : t -> int
(** Maximum number of file descriptors that can be observed at once. *)

val on_readable :
  t -> Unix.file_descr -> 'a -> 'b -> (closed:bool -> 'a -> 'b -> unit) -> unit

val on_writable :
  t -> Unix.file_descr -> 'a -> 'b -> (closed:bool -> 'a -> 'b -> unit) -> unit

val run_after_s : t -> float -> 'a -> 'b -> ('a -> 'b -> unit) -> unit

and nothing else. I've also started experimenting with using it to drive tiny_httpd.

• docs: https://c-cube.github.io/nanoev/
• release link: https://github.com/c-cube/nanoev/releases/tag/v0.1

I'm just back from the Mirage retreat, an event where people interested in Mirage meet for one week to work whatever they want. This retreat was organized by Hannes Mehnert as all past retreats, in Marrakech. Hannes ( @hannes ) asked participants to write a blog post to spread the word – hence this post.

I am pleased to announce the new package MlFront_Signify is available in opam.

signify was created by OpenBSD for maintainers to sign distributions and for users to verify those distributions. That is described in signify: Securing OpenBSD From Us To You and the signify manpage.

MlFront_Signify is compatible with signify. The C code comes from firmware update code for the embedded Linux router distribution OpenWrt (much easier to build using OCaml tools compared to OpenBSD code). The executable mlfront-signify has most of the same CLI options as OpenBSD signify and includes the same trivial tests as signify, but on Unix you should just use your package manager's signify. The main contribution of MlFront_Signify is the OCaml library that is documented at:

• https://dkml.gitlab.io/build-tools/MlFront/MlFront_Signify/MlFront_Signify/Signify/index.html

I used it with https://discuss.ocaml.org/t/ann-combining-llvm-mc-lld-precompiled-c-and-bytecode/16675?u=jbeckford to perform auto-upgrades. A few MlFront packages participate:

• MlFront_Signify to verify a potential upgrade
• MlFront_ZipFile to unpack a verified upgrade
• MlFront_Cache to provide an immutable store where multiple versions can co-exist

In particular, the SHA256.sig file in the file listing https://github.com/diskuv/dkcoder/releases/tag/2.3.202505202143 was created using MlFront_Signify with the SHA256 checksum file as input. That serves the same purpose as https://cdn.openbsd.org/pub/OpenBSD/snapshots/arm64/SHA256.sig.

MlFront_ZipFile has an important bugfix so please upgrade it to 2.3.1 as well.

Thanks to the Mirage project where I use its mirage-crypto-rng secure random generator!

Enjoy.

Greetings Cameleers,

We’re back with a new installment in our opam deep-dives series!

Opam 103: Bootstrapping a New OCaml Project with opam

This time, we’re taking a step back to focus on a beginner-friendly guide to setting up a toy OCaml project with opam, dune, cmdliner, and alcotest.

This article is aimed at newer members of the ecosystem who may be wondering:

• How do I structure an OCaml project from scratch?
• How to best use opam in my dev workflow?
• How do I write a minimal .opam file?
• What about a fully fledged one?

We walk through the opam rationale and offer guidance for building your first opam-compliant package — the kind you can confidently pin and use locally before getting to publishing it.

As always, we hope this piece serves as a helpful reference for those onboarding into the opam and the OCaml ecosystem and getting their first taste of the tooling.

:link: Check out the other opam deep-dives articles on https://ocamlpro.com/blog/

Feel free to share feedback or thoughts right here in this thread!

Thank you all for your time, and until next time, The OCamlPro Team

We believe that the two OCurrent pipelines setup for testing OCaml multicore have now served their purpose and will be retired.

• https://ocaml-multicoretests.ci.dev:8100
• https://ocaml-multicore.ci.dev:8100

Please let me know if you still feel these have value.

The Dune team is happy to announce the release of dune 3.19.0 :smile:

This release contains some important bug fixes along with some improvements for the foreign_library stanza. It introduces support for concurrent builds through the RPC server.

If you encounter a problem with this release, you can report it on the ocaml/dune repository.

I've written a tutorial on Record/Replay debugging. If you're interested in reverse debugging please check it out here.

You can do Record/Replay style debugging of your ocamlc.opt compiled executables. You will be able to place breakpoints on all symbols exposed by the ocaml.opt compiler – this includes C functions + OCaml functions from your OCaml program and do things like reverse-continue.

For more context please see an announcement I made a couple of months ago: https://discuss.ocaml.org/t/ann-a-tool-to-reverse-debug-ocaml-other-binary-runs/16366/1

(What's new in this new discuss.ocaml.org post is to give focus to the tutorial I've very recently written)

How can rr / Software Counters mode rr help me in OCaml if I'm not interested in gdb style debugging the OCaml executables ?

There are some other useful things that rr can do for OCaml-ers.

Here is one: Let's say you want to know what programs have been executed when you compile a ocaml program via dune.

$ dune init project hello_world
$ cd hello_world/
$ rr record -W -- dune b
rr: Saving execution to trace directory `/home/sidk/.local/share/rr/dune-5'.

Now run rr ps. You will get the exact invocations of all the programs that dune build triggered ! This takes you all the way down to showing you ld and ar invocations !

Very useful when you want to know what happened in the whole process tree.

editor’s note: please follow the post link to see this big terminal output.

Prompted by someone complaining online about Haskell documentation, I wrote a zero-maths guide to monads (in OCaml, but it applies somewhat more broadly, it's just OCaml has nice binding opearators):

https://raphael-proust.gitlab.io/code/no-maths-guide-to-monads.html

Hi!

I'm happy to announce the metal package with bindings to the Metal framework, with a relatively broad coverage except it does not cover anything graphics or UI related.

• Hosted on GitHub: lukstafi/ocaml-metal: OCaml bindings to Apple Metal for general compute applications
• API documentation: Metal (metal.Metal)
• Released to the repository: metal 0.1.0 (latest) · OCaml Package
• Example usage: ocannl/arrayjit/lib/metal_backend.ml at master · ahrefs/ocannl

Enjoy!

P.S. Disclaimer: code contains AI slop (and likely also my own errors). It's my first major employment of / "collaboration" with Large Language Models and I leaned into accepting choices made by the models.

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

• The origin of the pipeline operator (`|>`)