We're exploring systems applications for Oxidised OCaml (or 'OxCaml'). The language extension is primarily developed by Jane Street, and our group builds high-performance applications using it that are competitive with other systems languages. We've been working on mainline OCaml for a long time, and so we also perform stewardship activities around the OCaml community.
Our group is organised around three pillars. We're supporting the OCaml platform that comprises the compiler, package manager, CI infrastructure, and documentation systems. Then we're building live programming environments that put OCaml into browser notebooks and maps, with the aim of teaching algorithms as well as supporting planetary-scale exploratory research. Finally, we're figuring out the impacts of AI-assisted development on OCaml, ranging from training data to vibecoding etiquette.
As we're a university group we want to simultaneously do original research, share open code for the public good, and teach students who will carry these ideas forward. Therefore, this is all a highly collaborative effort. The team is a merry band of postdoctoral associates and PhD students, including myself (Anil), Jon Ludlam, Mark Elvers, Patrick Ferris, Ryan Gibb, David Allsopp (departed to Jane Street at the start of 2026), Sadiq Jaffer and Michael Dales. Everything below is joint work not only within our group, but also across close collaborators such as Tarides lead by Thomas Gazagnaire, the FP Launchpad lead by KC Sivaramakrishnan, Jane Streeters, and the wider community.
Here follows a review of roughly our first year of activity of OxCaml Labs (~Feb 2025 - Mar 2026):
- OCaml Stewardship >> Compiler (Relocatable OCaml, Runtime) · OxCaml extensions · odoc 3 · PPX · Package management & CI (CI, opam & dune, Research) · Outreachy & community
- Live Programming >> Browser-based OCaml · Hazel · Numerical computing · Planetary computing · GeoCaml · Data provenance
- AI-Assisted Development >> Benchmarks · Tooling · Advent of Agentic Humps · Redecentralisation
1 OCaml Stewardship
We maintain and extend the language, tools, and infrastructure that the open-source OCaml ecosystem depends on. This in turn benefits OxCaml, which is developed as a monorepo but with dependencies into OCaml itself.
1.1 Compiler development
Several of our group are core OCaml developers, and so we hack on the internals of the compiler itself. It's never been easier to contribute, even if you're a student just getting started so just have a go at it!
1.1.1 Relocatable OCaml
The headline achievement last year was getting Relocatable OCaml merged into mainline in December 2025 after a multi-year effort from David Allsopp, cheered on by the rest of us while carefully leaving him alone to hack on Makefiles. In OCaml 5.5, this landed as a cluster of PRs: #14244 lets the runtime locate the standard library relative to the binary, #14243 makes paths be interpreted relative to the config file, #13828 allows more reproducible .cmt files, and #14245 enables different runtime configurations to coexist via filename mangling.
Together these make it possible to ship self-contained OCaml installations without absolute paths. This might sound a bit pedestrian, but it's a critical feature for many modern packaging workflows. Once the compiler can be relocated without hardcoded paths, it means that binary builds can be downloaded and support features such as fast opam switch cloning, multistage Docker images, and cross-compilation that all need custom toolchains in specific locations. In general, an end user will experience much shorter bootstrap times for their OCaml toolchains.
We then backported all this to OCaml 4.13+ and cleaned up compiler packaging in opam, which should pave the way to using relocatable OCaml by default soon.
1.1.2 Runtime and backend work
Beyond our own PRs, we review and contribute to OCaml releases and tools to ensure the language stays robust. In OCaml 5.5, we reviewed thread-safe POSIX functions, Unix.unsetenv, Domain.count, and FlexDLL updates. In OCaml 5.4, we contributed string conversion functions for the C API, frame table linker fixes, frame pointer maintenance, cloexec fixes for Windows CRT descriptors, native symlinks on Windows, Windows target triplet validation. We reviewed the runtime events timestamp addition, making Gc.control globals atomic, and a Unix.getgroups fix for musl. Many of these are aimed towards winning on Windows while others improve the robustness and observability of multicore.
We also changed the free list representation in the shared heap to use run-length encoding, so sweeping takes time proportional to the live portion of the heap rather than its total size; this is sometimes 3-4x faster on sparse heaps (such as our multi-terabyte-RAM Epyc machines). This has been backported to OxCaml as well.
We also experimented with using effects in the compiler itself (#) and rethinking file descriptor abstractions for new IO interfaces like ocaml-uring, as well as how static linking works and OCaml 5.4 native ARM32 (out-of-tree, as 32-bit native output is being deprecated upstream).
1.2 OxCaml extensions and high-performance systems
It was a little daunting getting started with OxCaml, since it's got a high development velocity within the walls of Jane Street and we have lots of third-party libraries in our existing OCaml code that weren't quite compatible. The first thing we did was to do automated summaries of the (thousands) of GitHub issues around the ecosystem, in a system called thicket.dev, that has its own dedicated OxCaml section. I'm always wary of publishing LLM-generated text, but I review the output and it's also a very constrained usage (to summarise and link to issues), and (most importantly) I can't think of a reasonable alternative given the volume of activity ongoing.
Then while helping with the open source release last summer, we started building the infrastructure to make it easier to consume OxCaml alongside OCaml. We started with OxCaml base images and an opam-repository for OxCaml, and documented the experience of trying OxCaml and discovering its internals.
We had great fun helping to run an OxCaml tutorial at ICFP 2025 covering modes, locals, and performance engineering, and published a fun OCaml vs OxCaml Pi Day comparison. There were trip reports from multiple group members about the rest of ICFP, and our reflections covered new features like data race freedom and reflections on the multicore saga.
Once we were more comfortable with OxCaml, we started building research infrastructure for our own use. We built httpz, a zero-allocation HTTP/1.1 server using unboxed types and local allocations that now runs this website. We ported compression libraries (Brotli, Zstd, Snappy) to OxCaml in a monorepo to experiment with SIMD, built an ONNX inference engine using OxCaml SIMD intrinsics, and benchmarked GPU vs CPU inference.
We're using all these pieces to help train and infer TESSERA embeddings, which we talk about later in this post. The overall aim is an end-to-end native pipeline where satellite data arrives over HTTP, gets decompressed, inferenced, and served; the fast data transfers and transcodings are done using OxCaml. For fun, we also optimized an MP3 codec comparing OCaml and OxCaml performance.
1.3 Cross-linked documentation with odoc 3
odoc 3 is a major overhaul of OCaml's documentation generator. The earlier versions focused on feature coverage in order to replace the aging ocamldoc. odoc 3's theme is manuals instead of individual module documentation, via .mld files that let authors write comprehensive package documentation with cross-package linking.
odoc 2 could only link to dependencies, but odoc 3 can now link to any simultaneously installable package. This is a big deal for for multi-package projects like MirageOS or Core where the top-level package needs to reference dozens of libraries it doesn't directly depend on. Users can now write a single mld file that's a single-page tutorial. Odoc 3 also adds rendered source code navigation, type-based search via sherlodoc, a global sidebar, and media support so we can reference images directly in docs as well (or audio, although I'm not sure anyone's done that yet).
We deployed odoc 3 into production use on large codebases (including Jane Street's) with fixes for complex features such as module type of (these type-check fine but are surprisingly tricky to cross-link accurately in HTML). After this, we rolled it out on ocaml.org in July 2025, which required attempting to build all 17,000+ distinct package versions in the opam repository. The docs-ci runs on a dedicated 40-thread blade server, producing about 1 TiB of documentation over a couple of days. Common dependencies like dune are built thousands of times during this process — always producing identical binaries — so the new CI is far more efficient than the old pipeline, taking only a few hours to rebuild all docs when a new odoc version ships.
Once this went live (to positive reactions, thankfully) the rest of the year was spent on odoc bug fixes, sherlodoc search integration, and support for OxCaml modes and layouts. This is all essential groundwork for documenting the live programming libraries we're building in our research work!
1.4 PPX syntax extensions
OCaml's PPX system allows developers to extend the language with custom syntax transformations and code generation (similar in spirit to Rust's procedural macros and working at the AST level). That's the good news; the bad news is that every compiler release changes the AST, and someone has to update hundreds of downstream syntax extensions every time! This is a unglamorous, painstaking work as each bump requires auditing every PPX in the opam repository, sending patches, and coordinating with maintainers who may not be available. If everything isn't updated, then this results in grumpy users.
The community unified around ppxlib as the single framework for managing these AST upgrades. We help maintain it by bumping the ppxlib AST each time a new compiler version ships, and then sending patches to downstream PPX authors.
This work matters more than ever because OxCaml currently depends on PPX for practical use. OxCaml's mode and kind systems don't yet support full polymorphism natively, so you can't write a single identity function that works for both heap-allocated (global) and stack-allocated (local) values or for boxd and unboxed values. Until that lands in the type system, the ppx_template fills the gap to generate monomorphic copies for each instantiation (a bit like C++ templates). This means that virtually all OxCaml code (in particular the Base and Core libraries) flows through ppxlib.
We've been helping to upstream the ppxlib features that ppx_template needs, such as a new context-free rule type for attribute-based AST replacement, and fixing OOM errors that surfaced on larger codebases.
1.5 Package management and CI
Every OCaml project depends on a toolchain of compilers, package management, build systems, and continuous integration to turn source code into useful software. We maintain significant parts of this infrastructure and are also researching how to make it better.
1.5.1 Continuous integration
OCaml-CI is the shared CI service that automatically tests every package submitted to the opam repository across multiple OS and architecture combinations before it can be merged. We run and maintain the underlying cluster of build workers (spanning Linux x86/ARM64/PPC64/s390x/RISC-V, macOS, Windows and FreeBSD). Last year both our Scaleway and ARM sponsorships expired, so we spent time moving the cluster to Cambridge, issuing Docker base images for new compiler releases, adding Windows builds, FreeBSD, ARM64 workers, and 32-bit backends. We also documented how to distribute OCaml via Homebrew for macOS users.
OCaml-CI is built in OCaml using our OCurrent pipeline framework, and each package build runs inside a Docker container. We have a long history with containers since Docker Desktop's own networking stack (VPNKit) has been written in OCaml since 2016, and our retrospective on "A Decade of Docker Containers" made the front page of the Communications of the ACM! As part of our open-source contributions, we defunctorised VPNKit to port it to direct-style OCaml 5 with Eio, and reported on the overall experience of OCaml+Docker at ICFP 2025.
On the build side, Windows container support progressed from an initial QEMU backend (which provided some testing but was unreproducible for end-user debugging) to proper OBuilder on Windows HCS using the Host Compute Service. We've also compared BuildKit against OCurrent for image building. Our use of Windows containers may be one of the largest such deployments in the world, given the number of bugs we've encountered.
1.5.2 opam and dune
opam is OCaml's package manager, and dune is the build system that compiles OCaml projects. Together they form the basis of the OCaml Platform of out-of-the-box developer tooling. We help maintain the opam package repository and contribute to both tools.
The opam repository is a community-maintained collection of package metadata via a large Git repository where every OCaml library has a file describing its dependencies, build commands, and compatibility constraints. When someone runs opam install, a constraint solver finds a compatible set of packages. We help review and merge submissions, and maintain tooling around the repository itself.
Day-to-day maintenance included retiring legacy compiler versions from the CI matrix, migrating to opam 2.5, improving dependency solving and solver caching, and the perennial question of whether semantic versioning makes sense for OCaml (spoiler: no).
The bulk testing tool we built, Day10, takes a different approach to the standard CI by encouraging the use of merge queues. Instead of rebuilding an opam switch from scratch for each package (which recompiles common dependencies repeatedly), it assembles switches from pre-built component packages that are merged in overlayfs using hardlinks. This gets the entire package database rebuilt in half an hour on a single multicore machine, which we then use to compare builds across compiler variants. The end result is that we can now catching packages that break when switching from OCaml 5.4 to 5.5, or from mainline to OxCaml, much quicker than before.
1.5.3 Researching new formalisms
On the research end, we're developing formal models for dependency resolution that give insights into how to evolve systems like opam and Docker. The key finding is that dependency resolution across heterogeneous package managers can be unified via a single algebraic framework, which we're now using to prototype cross-ecosystem compatibility between opam, Nix and indeed any other language ecosystem.
This started with using hypergraphs for version resolutions and then "Package Managers à la Carte: A Formal Model of Dependency Resolution" that formalises dependency resolution across PL ecosystems. We built the Pac tool, got opam-nix integration merged upstream, and presented three talks at FOSDEM 2026: package management formalised, Eilean, and Opam's Nix mechanism.
1.6 Outreachy and community
A healthy programming language needs a welcoming community. Outreachy provides paid internships in open source for people underrepresented in tech, and OCaml's participation goes all the way back to 2015. We've been coordinating it for the past several rounds, funded by Jane Street and Tarides. Outreachy has been a wonderful source of new OCaml developers, though the programme itself is facing funding challenges in recent years.
In the June 2025 round, we mentored two interns: one built Claudius, a fantasy-console graphics library, and another extended dune with to discover system information. The December 2025 round was our largest yet with four interns:
- an OxCaml backend for Raven (now merged upstream with benchmarks approaching the C backend!), and also an ML experiment dashboard also for Raven. There's more about the Raven backend below including a video.
- better errors for YOCaml
- writing TIFF files in pure OCaml which feeds directly into our geospatial stack.
We also try to issue monthly OCaml Roundups or quarterly summaries or more detailed writeups on coding agents and fixes to the OCaml runtime. We also wrote an Irmin retrospective looking back at a project that's been going for over a decade now, and is about to have direct style IO integrated.
Fun experiments also abound: we're running multicore OCaml 5 on a Raspberry Pi Pico 2 microcontroller, building eInk display drivers on a Raspberry Pi, writing a complete ray tracer in OCaml usng TSDL, OCaml 5 Domains, and Atomics (with performance work on reducing heap allocations), building an OCaml static site generator for blogging via webplats, and getting into FPGA programming with HardCaml.
2 Live Programming
Our second pillar of work is about making OCaml executable in new contexts than just binaries, via publishing to the web for lecture slides, interactive notebooks, satellite maps, and even numerical computing. This connects our teaching mission to our research since the same tools can let students explore algorithms and also let ecologists explore satellite embeddings on a live map. The common thread is bringing OCaml's traditional advantages like static type safety into interactive, explorable environments that are usually more dynamic (a euphemism for saying that we just don't want to program frontends in Javascript).
2.1 Browser-based literate OCaml
The foundation for all of this is js_of_ocaml, which compiles OCaml to JavaScript, and increasingly wasm_of_ocaml for WebAssembly. We've been building on top of these to create interactive programming tools.
Arthur Wendling wrote x-ocaml as a web component that compiles and runs OCaml code directly in the browser, with type-on-hover and programmatic code highlighting. After my ICFP OxCaml tutorial first used it, Jon Ludlam combined it with Slipshow for presentations to power our interactive lecture slides for the Cambridge 1A Foundations of Computer Science course. Jon also took over my course for the 2025-2026 year as I've been on sabbatical, and his lectures saw him modify and execute code snippets live; especially useful for the notorious "giving change" algorithm in the middle of the course that trips up many a first year undergrad!
All this is building towards a broader OCaml-based literate programming infrastructure. This first introduces a new odoc plugin infrastructure, and example plugins for admonitions, Mermaid diagrams, and even Scrollycode tutorials. The end goal is a serverless deployment, using web workers to run OCaml code fully in the browser. This matters to us not just for robustness and longevity, but also when writing code for deployments in remote field stations when building biodiversity monitoring applications.
2.1.1 The Hazel connection
There's a connection to another exciting browser-based live programming environment in the form of Hazel. We built a transpiler from OCaml to Hazel (paper), bootstrapping a corpus of ill-typed OCaml programs for the Hazel live programming environment. Hazel provides richer interactive feedback than a simple toplevel since it can reason about incomplete and ill-typed programs via "typed holes".
This gives us a bootstrapped corpus of ill-typed code in Hazel to build type level debuggers and eventually could provide students with feedback on why their code is wrong, not just that it's broken (a common frustration with statically typed PLs).
Another connection to OCaml here is that the Hazel interpreter is itself written in OCaml and compiled to Javascript. We're interested in using OxCaml's performance features to speed this up, and try to use Hazel's live programming features as a DSL for live computational wikis.
2.2 Numerical computing
OCaml is traditionally 'ok' at floating point numerical code, but hasn't quite kept up over the years with newer advances. OxCaml has a number of performance-oriented features such as small numbers and SIMD which improve this. We've been investigating how to use these for both traditional CPU-based algorithsm as well as GPU-based machine learning training and inference.
2.2.1 Planetary computing with TESSERA and LIFE
A major application of our live programming work is deploying the TESSERA, a pixelwise geospatial foundation model geospatial model, which involves manipulating petabytes of satellite data. We've been building out the data infrastructure for earth observation, biodiversity monitoring, and geospatial analysis in a heady combination of Python, OxCaml and shell scripts.
We built an end-to-end TESSERA inference pipeline in OCaml using ONNX bindings, progressing through early Zarr v2 support and STAC tile serving. The OxCaml-Zarr transcoding pipeline went from prototype to browser-based streaming via wasm/WebGPU, and the full Zarr v3 conventions are now documented with a shared community convention. We demonstrated finding solar farms with a 42k-parameter model using these, and built OpenStreetMap protobuf and DuckDB bindings in OxCaml for combining vector data with pixel embeddings.
Our first prototypes were written in Python, and then OCaml TESSERA notebooks bring this back to our functional world. The notebooks let users draw regions on a map, fetch embeddings, place training labels and run classification all entirely browserside-side in OCaml compiled to JavaScript with no server required!
We also worked on Parquet file optimization for geospatial data formats. The Yirgacheffe declarative geospatial library, which we're also currently porting to OxCaml, and its role in our biodiversity pipeline is covered separately in the Mapping LIFE on Earth project.
2.3 Raven and nx-oxcaml
An Outreachy intern, Nirnay Roy, built nx-oxcaml, an OxCaml backend for the Raven numerical computing library. It uses unboxed primitive types (float#, int32#) for zero-allocation numeric operations, and early benchmarks show it approaching the C backend's performance!
This is a super exciting early validation of OxCaml's promise for us. It looks like we've got a high-level functional language that's approaching being competitive with C for numerical workloads, and reasonable enough to use to have been built during an internship in three months. There's still work to be done, but it's getting there!
2.3.1 GeoCaml
We're assembling geocaml, a suite of pure OCaml geospatial libraries that can eventually replace C dependencies like GDAL for our use cases.
The centrepiece is ocaml-tiff, a pure OCaml TIFF reader and writer that can handle GeoTIFFs as well. Our Outreachy intern Tambe Salome delivered LZW decompression speedups and added write support. Tambe also wrote up her own experiences about the internship.
We also maintain OCaml bindings to PROJ4 for coordinate reference system projections, a WKT codec for the well-known text format, an R-Tree spatial index adopted from old friend Marius Eriksen, and ocaml-geojson.
The goal here is to reach a critical mass where these libraries can reinforce each other so we can stay in pure OCaml for common geospatial tasks. We're getting there with early success porting geotessera to OCaml using ocaml-tiff for landmasks and Nx for array operations, and the interactive browser notebooks.
2.3.2 Shells for a modern, less civilized age
Shelter is a data provenance system built with OCaml and Eio that uses eBPF tracing to track how data flows through scientific pipelines. It supports imports for modularity and sessions with full lineage tracking, and we've been working on running the Mapping LIFE on Earth biodiversity pipeline through it to get end-to-end data provenance.
Since any reasonable Unix distribution needs a POSIX compatibility story, we've also been working on Merry, a complete POSIX shell in OCaml! While Merry is usable today, the pieces are currently being fitted together to build a complete time-travelling Linux shell!
What I am particularly interested in reasoning about, is the execution context in Merry. This value, alongside the file-system, constitutes a fairly deep understanding of the state that changes in each step of a shell's evaluation loop.
This was, in terms of Shelter, the missing piece for truly building some kind of MRDT across shell sessions. -- Merry, Patrick Ferris, 2026w12
Reproducible provenance of computational pipelines is fast becoming a requirement for evidence-based policy. Our work on global biodiversity frameworks calls for auditable chains of evidence from raw data all the way to reported indicators, or we risk wasting resources on low-impact interventions.
We also co-organised the second outing of the Programming for the Planet workshop at ICFP, gathering functional programmers interested in planet-positive action. PROPL 2026 returns at PLDI in Boulder with an action-oriented format later this year!
3 AI-Assisted OCaml Development
Claude Code appeared just as we started OxCaml Labs in March 2025, and has completely turned software development on its head. Our goal here is in some ways just keeping up, but also in advancing our understanding in what AI-assisted development means for a strongly-typed functional language. This ranges from improving the training data quality to the social etiquette of working alongside agents.
3.1 Contributing OCaml benchmarks
A low-resource language that isn't represented in AI benchmarks and training data risks being left behind as coding agents improve. We've been working to make sure OCaml is in the mix.
We presented Three steps for OCaml to crest the AI humps at the 2025 OCaml Workshop, benchmarking OCaml's representation in foundation models. We curated an opam archive dataset for LLM training — extracting structured code from thousands of opam packages to give models more OCaml to learn from. We then evaluated 19 local LLMs on OCaml (finding that Qwen3-32B nearly matches Claude at a fraction of the cost, which is promising for self-hosted coding agents), and contributed an OCaml GC debugging task to the terminal-bench AI agent benchmark suite — a real runtime bug that tests whether agents can reason about garbage collector internals.
3.2 Tooling for agentic OCaml
On the tooling side, we built an OCaml MCP server and integrated ocaml-lsp via MCP for AI coding, surveyed the broader ecosystem, and published a prebuilt devcontainer for OCaml/OxCaml with Claude Code and explored adversarial approaches to teaching OxCaml to agents.
To keep up with the firehose of activity across OCaml's GitHub repositories, we built Ruminant, an LLM tool that syncs thousands of issues, PRs and discussions and uses Claude to generate condensed weekly digests. This is now published regularly on thicket.dev for the OCaml ecosystem.
3.3 The Advent of Agentic Humps
To really push the limits, I ran a December Advent of Agentic Humps sprint, building 25 O(x)Caml libraries in 25 days with Claude Code. At a high level, it worked surprisingly well for a relatively low-resource language like OCaml. Several patterns (not quite lessons just yet) emerged:
-
Specifications as source code. Feeding agents formal specs like RFCs or WHATWG standards produced good results when combined with external test suites. We built HTTP cookie, punycode and public-suffix libraries from RFC text alone, a pure OCaml Yaml 1.2 parser that passes 20% more tests than C libyaml (and is 20% faster), and TOML 1.1 codecs reaching 100% of the toml-test suite.
-
Error messages guide agents. Well-designed libraries with precise error messages (particularly jsont and its typed codecs) let agents self-correct in a loop. This proved useful when debugging against live APIs and when reverse-engineering protocols from multiple language SDKs. The bidirectional codec pattern generalised across Yaml, TOML, and INI.
-
Source code context across languages beats documentation. Providing agents with working implementations to study consistently outperformed docs alone. For an HTTP client, we aggregated best practices from 50 implementations across 10 languages. For Eio-based libraries, cloning the source repo and pointing at the README was enough. We built monopam and unpac for assembling monorepos where agents have full local context, a pattern now natively supported by Claude Code.
-
Self-healing and recursive testing. When external test suites don't exist, building tools that test themselves works well: a Zulip bot exercising its own API, and a feed aggregator that patches its own parsing code. OCaml's type system is a reasonable guardrail here and we think it improves agentic coding quality compared to Python. However, the code produced is "unoriginal" and often verbose; good for parsing and utility libraries, but not a substitute for creative design. We treat all agent output as "slop by default" until human-reviewed.
Outside the Advent, we tried agentic bug hunting, experimented with Claude completing IMAP protocol specs and controlling hosts with OCaml, and tried to used it to build dune odoc rules as a first foray into upstreaming code with an agent.
On the community side, there's been a rollercoaster of conflicting incentives with AI slop encroaching on traditional repositories. We're working on clearer norms amongst ourselves around attribution and code review for AI-assisted contributions to open source repositories, drawing on our vibecoding etiquette guidelines.
3.4 Evolutionary redecentralisation
It wouldn't be any fun to be in a university if we didn't try something really crazy. We have a long history of working on self-hosted infrastructure, federated services, and distributed systems using MirageOS and modern OCaml.
Our Ecology of/for the Internet paper (presented at the decennial Aarhus conference) argues that the Internet is dangerously ossifying into software monocultures. We're wondering if the fix actally comes from an unlikely source: use AI code models to deliberately introduce diversity!
The idea is to mutate end-host software stacks (often written in OCaml via MirageOS) so that each deployment is slightly different from its neighbours, much like how genetic diversity in a wild population prevents a single pathogen from wiping out the entire species. We dubbed this the "antibotty" approach due to the irresistable pun: use locally adapted software vigilantes (antibodies) that fight back against global botnets. This also turns the biggest down side of generative AI (that it's unpredictable) into a useful property when you actually want more local diversity. OxCaml may be surprisingly important here, since its extra type and kind information helps constrain the runtime characteristics of AI-generated code.
So it's not too pie in the sky, we're building the practical pieces to make this work without using any AI. Eilean is a self-hosted digital islands platform using Nix, and Eon is an effects-based OCaml DNS nameserver using Eio. Our Bifrost network introduces a programming model using bigraphs for spatial networking, enabling policies scoped by physical boundaries. Tangled code hosting now supporting opam packages is also another small step to reducing our reliance on GitHub.
All in all, we don't know where this brave new AI world is taking us, but we're going to inject some entropy into the works to help ensure that decentralisation and local agency remains an option!
Activity
Publishing the OxCaml Labs year-one review, POSSE and AI content disclosure for the web, adopting the geo-embeddings Zarr convention for TESSERA, action PROPL at PLDI, the death of the grant application, and NASA's new swathe lidar mission.
Community feedback reshaped our Zarr store layout — years became a dimension, shards got bigger, and we retired the TESSERA-specific convention in favour of a shared geo-embeddings standard that also covers other models.
The OCaml community participated in the December 2025 round of Outreachy internships. We had four interns working on Raven and OxCaml, OCaml-TIFF and YOCaml. This meeting was an opportunity for the interns to present their work and for the community to ask questions and was originally announced on the discuss forum.
. This post walks through how to use mtelvers/day10 to compare which opam packages build successfully under two different compiler configurations.
Evidence synthesis at the DEFRA science conference, TESSERA transcoding and building a new SPA, OpenStreetMap/DuckDB bindings in OxCaml, and early thoughts on vibecoding etiquette.
How we restructured TESSERA's geospatial embeddings from millions of individual numpy files into sharded Zarr v3 stores for efficient HTTP streaming, enabling everything from single-pixel mobile lookups to regional-scale analysis with just a couple of range requests.
Mark Elvers. For Pi Day, I have implemented the same algorithm in both OCaml and OxCaml and compared the generated assembly and runtime performance.
Mark Elvers. The UK government recently launched the Fuel Finder API, providing real-time pricing data for over 7,000 petrol stations across the country.
Mark Elvers. Following my previous CPU vs GPU post I started thinking about what the ONNX inference engine actually did and if it could be replicated in OxCaml with SIMD.
Mark Elvers. In a previous post, I compared the ONNX Runtime with PyTorch on the CPU and GPU. In this post, I take this to the extreme to see if a CPU can outpace the NVIDIA L4 GPU.
Patrick Ferris. Much like last month, this month has been busy with lots of work on ocaml-tiff thanks to Tambe Salome and ppxlib. Outreachy Tambe Salome, at the time of writing, has completed her internship! We will be hosting the biannual Demo Day celebration for this round's interns, so please do come along. Sinc…
Patrick Ferris. I am yet to jump head-first into using LLM-based tools like Claude Code or even ChatGPT to help with my programming in any serious way. After using some "free"-tier tools to try to better understand some tricky eBPF problems and to make sense of the semantics of POSIX shells, I was left un…
Mark Elvers. We use OCluster to manage the build cluster for the CI services backing OCaml-CI and opam-repo-ci. However, it is a general-purpose tool and isn’t tied to being a build system; it can distribute any jobs across multiple worker machines.
Jon Ludlam. Here are my weeknotes for the last week, while I'm still writing up some more focused posts on some specific topics - like the experience of putting everything in a monorepo to create this site, and m...
A little screencast of a fully browser based streaming interface to manipulate TESSERA embeddings. All the classification and UMAPs run directly in a browser, with no server required aside from static HTTP serving of the embeddings!
Summary of the Nine Recommendations and Biodiversity Monitoring Standards Framework papers from the NAS/Royal Society US-UK Forum in summer 2025, and how they connect to my work on collective knowledge systems, TESSERA, and evidence synthesis.
Mark Elvers. Following on from the Arm32 multicore backend, I have now ported the remaining two 32-bit architectures to OCaml 5 with multicore support: i386 and PowerPC 32-bit (PPC32).
Mark Elvers. Following from post last week about obuilder and Windows Host Compute Services, I am pleased to report that this is now running on OCaml-CI. In this early phase, I have enabled testing only on Windows 2025 with OCaml 5.4 and opam 2.5 using the MinGW toolchain.
Jon Ludlam. Let's make this really terse!
Anil Madhavapeddy, David J. Scott et al. — Communications of the ACM
Got TESSERA working in Zarr and the browser, and a preprint of package management a la carte pushed out
Mark Elvers. Mainly for my future reference here is a walk-through of the Tessera pipeline.
Our CACM cover article reflects on a decade of Docker, from the early days of hacking Docker for Mac on a French farm to today's AI-driven sandboxing, covering the technical origins, cross-platform challenges, and the vibrant open-source community that made it all possible.
Jon Ludlam. A combination one again as I took some time off due to school half term.
Mark Elvers. Following from my containerd posts last year and my previous work on obuilder backends for macOS and QEMU, this post extends obuilder to use the Host Compute System (HCS) and containerd on Windows.
Michael Dales. This is a bit of a meandering blog post, which was meant to be about one thing, and then I had to pull in some other bits to give context, and now it feels a little incoherent. However, I do think somewhat that is part of the broader point I'll try to make at the end, about the challenge of solving …
Mark Elvers. ocurrent/obuilder is the workhorse of OCaml CI testing, but the current deployment causes packages to be built repeatedly because the opam switch is assembled from scratch for each package, leading to common dependencies being frequently recompiled. day10 uses an alternative model whereby switches a…
Growing the Ceph cluster for TESSERA embeddings, a Lego brainstorming session for the Evidence TAP, hosting Echo Labs from ARIA, and Shane's IUCN Red List seminar.
Mark Elvers. The Tessera pipeline is written in Python. What would it take to have an OCaml version?
Mark Elvers. After reading Anil’s post about his zero-allocation HTTP parser httpz, I decided to apply some OxCaml optimisation techniques to my pure OCaml MP3 encoder/decoder.
PhD viva for Maddy, presenting TESSERA at ARIA, Nature covers the conservation evidence conference, giving evidence to Parliamentary POST, and a CACM interview.
Patrick Ferris. A new year, another roundup in my open-source, OCaml activities. This month has been busy with lots of work on ocaml-tiff thanks to Tambe Salome and ppxlib. Outreachy Tambe Salome has been working to add write support to ocaml-tiff; and we are well on the way to having good support. Writing TIFF fil…
Ryan Gibb explains why package managers are legion. Every language and operating system has its own solution, each with subtly different semantics for dependency resolution. This fragmentation prevents multi-lingual projects expressing precise dependencies across languages.
Hosting the UK chief scientists for nature conservation at Pembroke to discuss TESSERA and AI for biodiversity, followed by the Conservation Evidence conference where I talked about choosing the open red pill over black-box AI for conservation decision-making.
Deploying an OxCaml zero-allocation webserver, OCaml CI maintenance and opam versioning, and OCaml Workshop and FOSDEM talks
Building httpz, a high-performance HTTP/1.1 parser with zero heap allocation using OxCaml's unboxed types, local allocations, and mutable local variables.
Ryan Gibb. Feb. 2026Ryan Gibb, Patrick Ferris, David Allsopp, Thomas Gazagnaire, and Anil Madhavapeddy.arXiv. Package managers are legion. Every programming language and operating system has its own solution, each with subtly different semantics for dependency resolution. This fragmentation prevents multilingu…
Jon Ludlam. I've been battling the seasonal illnesses this week, so I've combined two weeknotes into one. Fortunately the 'flu doesn't hold Claude back!
Michael Dales. I claimed last week that I'd have to put aside the fun I was having working through the Ray Tracer Challenge book in OCaml due to other commitments. And technically that was true, I didn't get to do any new features based on the book, I had a couple of longish train trips, and so I did go off piste …
Mark Elvers. With Claude Code, perhaps we are now at the point where the test suite is actually more valuable than the code itself.
Mark Elvers. As our workflows become more agentic, CLI tools are becoming preferred over web GUIs; OCurrent pipelines are no exceptions.
Jon Ludlam. First week back of 2026! Let's write some terse weeknotes.
David Allsopp. On 16 December 2000, a young @dra1 stepped out on to the stage of St Martin-in-the-Fields making what would be the first of many performances of Johann Sebastian Bach’s great Mass in B minor. On 16 November last year, just under 25 years later, a slightly greyer @dra27 stepped out on the stage of …
David Allsopp. The spring-cleaning continues! When I originally prototyped Relocatable OCaml, it was during the OCaml 4.13 development cycle. The focus for the work originally was always about multiple versions of the compiler co-existing without interfering with each other, so even the early prototypes were done …
Mark Elvers. Early in the upgrade program for Ubuntu 24.04, there were permission issues when extracting tar files. The workaround was to update to the latest dev version of Docker. However, this didn’t resolve all the issues on ARM64, so only one machine was updated and excluded from the base image builder wo…
Sadiq Jaffer. Satellite imagery analysis doesn't always require massive data and compute. We show how to combine open data from OpenStreetMap and the UK Government's Renewable Energy Planning database with Tessera foundation model embeddings to map solar farms across the UK using a lightweight neural network.
Mark Elvers. opam 2.5.0 was released on 27th November, and this update needs to be propagated through the CI infrastructure. This post mirrors the steps taken for the release of opam 2.4.1.
Patrick Ferris. December was busy, both personally and in my OCaml-related work. If you haven't been following along have a read of my October and November roundups. Outreachy December Round December marks the beginning of a new Outreachy round, and I am very excited to be working with Tambe Salome on improving the…
David Allsopp. As we settle into 2026, I have been doing a little early spring-cleaning. A few years ago, we had a slightly chaotic time in opam-repository over what should have been a migration from gforge.inria.fr to a new GitLab instance. Unfortunately, some release archives effectively disappeared from officia…
Mark Elvers. Extending the Pico 2 implementation to add effects-based WiFi networking and improve the build system.
A prebuilt Docker devcontainer for sandboxed OCaml and OxCaml development with Claude Code, including multiarch builds and network isolation.
Michael Dales. For the last few years I've spent the run up to the festive break working on something graphical, and this year whilst I was a little late to start, I decided to have a go at the Ray Tracer Challenge book by Jamis Buck. This book provides a language-neutral guide to building a classic old-school ray…
Ryan Gibb, Patrick Ferris et al.
Ryan Gibb. Jan. 2026Ryan Gibb.Free and Open Source Software Developers’ European Meeting (FOSDEM). Our digital lives are increasingly fragmented across numerous centralised online services. This model concentrates power, leaving us with minimal technical control over our personal data and online identities. …
Ryan Gibb. Jan. 2026Ryan Gibb.Free and Open Source Software Developers’ European Meeting (FOSDEM). Package managers are legion. Every language and operating system has its own solution, each with subtly different semantics for dependency resolution. This fragmentation prevents multi-lingual projects expressi…
Ryan Gibb. Jan. 2026Ryan Gibb.Free and Open Source Software Developers’ European Meeting (FOSDEM). The OCaml language package manager, Opam, has support for interfacing with system package mangers to provide dependencies external to the language. Supporting Nix required re-thinking the abstractions used to i…
Mark Elvers. Running OCaml 5 with multicore support on bare-metal Raspberry Pi Pico 2 W (RP2350, ARM Cortex-M33).
An exploration of agentic programming through building useful OCaml libraries daily using Claude Code while establishing groundrules for responsible development.
Tuatara is a feed aggregator that integrates Claude to evolve and patch its own code when encountering parsing errors, embodying the concept of self-healing software.
Introducing unpac, a tool that unifies git and package management into a single workflow where all code dependencies live in one repository as trackable branches.
Materialising opam metadata into git submodules and monorepos, enabling cross-cutting fixes and unified odoc3 documentation across dozens of OCaml libraries.
Building an OCaml Zulip bot framework with functional handlers, and pivoting from TOML to INI codecs for Python configparser compatibility
Building tomlt, a pure OCaml TOML 1.1 parser with bidirectional codecs following the jsont design patterns
Jon Ludlam. Back in March of this year we released , a major new version of the OCaml documentation generator. It had a whole load of , many of which came with new demands on the build system driving it. We decid...
David Allsopp. As I was very happy to announce on Discuss on 12 December, OCaml is Relocatable! Today, the final piece of the puzzle was merged, which is the necessary support to allow opam to take advantage of all this to be able to clone switches instead of recompiling them. Before this, you could rename a local…
Vibe coding an OCaml library for the Karakeep bookmarking service by giving an agent a live API key and letting it debug jsont codecs against the real service.
Agentically synthesising a batteries-included OCaml HTTP client by gathering recommendations from fifty open-source implementations across JavaScript, Python, Java, Rust, Swift, Haskell, Go, C++, PHP and shell.
Synthesizing three RFC-compliant libraries (punycode, public-suffix, and cookeio) directly from Internet RFC specifications, establishing a workflow for automating standards implementation with proper cross-referencing to spec sections.
Patrick Ferris. A roundup of some of my OCaml activity this month! Ppxlib Updates I managed to get a substantial amount of ppxlib work completed in the last month. Some of those bits are described in detail below. Initial OCaml 5.5 Support We recently merged 5.5 support into our main branch (thanks to Nathan for th…
Building yamlt to enable jsont codec definitions to work with both JSON and Yaml, providing data manipulation with location tracking and good error messages for both formats.
Implementing a pure OCaml Yaml 1.2 parser using bytesrw by synthesizing from the specification and existing C library behavior, passing thousands of test suite cases while being 20% faster than the C-based implementation.
Three steps for OCaml to crest the AI humps, OCaml 2025 by Sadiq Jaffer, Jonathan Ludlam, Ryan Gibb, Thomas Gazagnaire, and Anil Madhavapeddy. We discuss how OCaml could adapt to the fast-moving world of AI-assisted agentic coding. We first benchmark how well represented OCaml is in the large and diverse set of open weight models that can be run locally. We then consider what is unique about OCaml programming (in particular, modules and abstraction) that differentiates it in this space. We then consider the changes required in our ecosystem to work better with AI coding assistants. Presentation at the OCaml 2025 workshop, Oct 17, 2025, https://conf.researchr.org/home/icfp-splash-2025/ocaml-2025.
Docker is a developer tool used by millions of developers to build, share and run software stacks. The Docker Desktop clients for Mac and Windows have long used a novel combination of virtualisation and OCaml unikernels to seamlessly run Linux containers on these non-Linux hosts. We reflect on a decade of shipping this functional OCaml code into production across hundreds of millions of developer desktops, and discuss the lessons learnt from our experiences in integrating OCaml deeply into the container architecture that now drives much of the global cloud. We conclude by observing just how good a fit for systems programming that the unikernel approach has been, particularly when combined with the OCaml module and type system.
A guided tour through Oxidized OCaml at ICFP/SPLASH 2025 by Gavin Gray, Anil Madhavapeddy, KC Sivaramakrishnan, Will Crichton, Shriram Krishnamurthi, Chris Casinghino, and Richard A. Eisenberg. OxCaml is a set of extensions to the OCaml programming language that form Jane Street’s production compiler for performance-oriented programming. OxCaml’s primary design goals are to provide safe, convenient, predictable control over performance-critical aspects of program behavior while preserving ML-style programming ergonomics. This tutorial will focus on key extensions in OxCaml, such as: fearless concurrency: additions to the type system to statically rule out data races. data layouts: providing more control over how data is laid out in memory and native access to vector instructions. allocation control: reducing GC pressure and improving cache efficiency and determinism.
Mark Elvers. OCurrent has long wanted to access private repositories. You can achieve this by embedding a scoped PAT in the .git-credentials file, typically within the Docker container; however, this is untidy, to say the least! The approach presented works in cases where a GitHub app is used.
Creating OCaml bindings for the Claude API using Eio and jsont codecs by reverse-engineering the JSON-RPC protocol from Python and Go SDKs, enabling Claude to write more Claude-powered OCaml code.
Building an XDG Base Directory Specification library with Eio capabilities and Cmdliner integration, providing sandboxed filesystem access patterns with full environment variable and CLI override support.
Mark Elvers. My throw-away comment at the end of my earlier post shows my scepticism that the JSON file approach was really viable.
Building a Base32 Crockford encoding library in OCaml using Claude Code, establishing the development workflow with sandboxed Docker containers and local development environments.
David Allsopp. Someone was kind enough a few weeks ago to comment on Hacker News that “Opam on Windows is a masterpiece of engineering”. There’s certainly a lot which has to go on under the hood to create what I believe is the necessary baseline experience. Unfortunately, it doesn’t always work out.
Mark Elvers. I’ve been copying the TESSERA data to Cephfs, but what is actually in the files?
Mark Elvers. Recently, I have been using my Pi Zero (armv6), which has reminded me that OCaml 5 dropped native 32-bit support, and I wondered what it would take to reinstate it.
Patrick Ferris. A late update that stretches more than a week... @ How? A quick update on a new feature that was added recently, the @ how meta-command. One of the issues facing any exploratory programmer (or indeed anybody returning to a project) is the provenance of a given file. How that file came to be and who …
Mark Elvers. The weather outside is frightful, but the Raspberry Pi is so delightful; I have been cheering myself by connecting up all the various bits of hardware scattered on my desk. I often buy these components but never quite get around to using them.
Patrick Ferris. Most of this week was spent fixing bugs in Shelter in an attempt to get it ready to run the LIFE pipeline. To do so, Shelter requires a mechanism by which to pull in files from the outside world. That could be configuration files, source trees, data etc. For now, this has taken the form of a crude @…
Jon Ludlam. I recently completed lecturing the course to our newly arrived first-year computer scientists here at . This is the first time I've lectured this course, taking over from while he's on sabbatical. A...
Ryan Gibb. I attended the co-located International Conference on Functional Programming (ICFP) and International Conference on Systems, Programming, Languages and Applications: Software for Humanity (SPLASH) as a co-author of a couple of papers, and was presenting ‘Spatial Programming for Environmental Monit…
Patrick Ferris. Welcome to a monthly roundup of OCaml-related open-source work I have been involved with. If you haven't already, a quick look at my ICFP roundup might be a good preface to what follows. Outreachy December 2025 The contribution period for this year's Outreachy round took place for most of the month …
Zhengpeng Feng, Clement Atzberger et al.
Sadiq Jaffer. OCaml represents less than 0.01% of training data for many large language models, creating an existential threat for the language community. This talk outlines three concrete steps the OCaml community can take to improve AI coding agent support and ensure the language's future relevance.
Patrick Ferris. Two weeks ago I was fortunate enough to attend the International Conference on Functional Programming in Singapore. My first time in Asia and my second time at the conference, what follows are some thoughts and presentations I enjoyed whilst I was there. I must thank my office mate (and friend!) Rya…
Mark Elvers. Following the release of OCaml 5.4 the CI systems need to be updated to use it.
David Allsopp. I spent last week at ICFP 2025. A nice (if exhausting!) week, as ever. Amusingly, the most reflections were actually sparked by Yaron’s talk which was right at the end (you can see the talk itself on YouTube).
Five-part series overview covering workshops, tutorials, talks and keynotes from ICFP/SPLASH 2025 in Singapore.
Mark Elvers. We are increasingly hitting the Docker Hub rate limits when pushing the Docker base images. This issue was previously identified in issue #267. However, this is now becoming critical as many more jobs are failing.
Jane Street's production deployment of OCaml 5 and Docker's migration to direct-style programming with Eio presented at ICFP.
Mark Elvers. The FreeBSD CI worker rosemary needs to be updated to FreeBSD 14.3.
Tutorial at ICFP 2025 on OxCaml extensions for performance engineering with modes and locals.
Report on second Programming for the Planet workshop featuring papers on climate modeling, geospatial computation and planetary-scale collaborative systems.
Sadiq Jaffer, Jon Ludlam et al. — proceedings of the 2025 OCaml Workshop
Josh Millar, Ryan Gibb et al.
Cyrus Omar, Michael Coblenz et al. — Proceedings of the 2nd ACM SIGPLAN International Workshop on Programming for the Planet
Patrick Ferris, Anil Madhavapeddy — proceedings of the 2025 Workshop on Type-Driven Development (TyDe)
Ryan Gibb. Oct. 2025Sadiq Jaffer, Jon Ludlam, Ryan Gibb, Thomas Gazagnaire, and Anil Madhavapeddy.Proceedings of the 2025 OCaml workshop. We discuss how OCaml could adapt to the fast-moving world of AI-assisted agentic coding. We first benchmark how well represented OCaml is in the large and diverse set of ope…
David Allsopp. Continuing the previous foray into file descriptors, and trying to remove Obj.magic both from ocaml-uring’s code itself, and from the recommended way for using it.
David Allsopp. There was a flurry of activity on ocaml-multicore/ocaml-uring this month leading to a release (ocaml/opam-repository#28604). ocaml-uring provides bindings to the Linux’s io_uring, which allows batching various syscalls to the kernel for it to execute out-of-order, and in parallel. Its principal us…
David Allsopp. Continuing the previous theme of dabbling with matters agentic. Previously, I’d quite assiduously kept my fingers away from files. This time, I wanted to try something exploratory, switching to the agent for things I was actively stuck on.
David Allsopp. Over the summer, Lucas Ma has been investigating ideas surrounding using effects in the OCaml compiler itself. He’s blogged some of his discoveries and adventures. The technical core of this work leads towards being able to use the OCaml compiler as a library on-demand to create a longer-lived “…
Jon Ludlam. Some results from the . This time I've run day10 on 144 or so commits from opam-repository to see how well the cache performs. The results are quite interesting.
Jon Ludlam. This post is a brief write-up of a couple of bugs in odoc that I've been working on over the past 2 weeks. I was convinced at the start of this that I was actually fixing one bug, but although they bo...
Mark Elvers. Yesterday I wrote about the amazing performance of Apache Parquet files; today I reflect on how that translates into an actual application reading Parquet files using the OCaml wrapper of Apache’s C++ library.
Mark Elvers. If you haven’t discovered the Apache Parquet file format, allow me to introduce it along with ClickHouse.
Jon Ludlam. The system works by watching opam-repository for changes, and then when it notices a new package it performs an opam solve and builds the package, a prerequisite for building the documentation. In or...
Jon Ludlam. , and I have been working on a system to build opam packages similar to the way that the docs-ci system does - effectively building a per-package binary cache to do very fast builds of the entire opa...
Jon Ludlam. Here's a quick post on how to get the OCaml Language Server (ocaml-lsp-server) working with an MCP server.
Mark Elvers. I’ve been thinking about terminal-based GUI applications recently and decided to give notty a try.
Presentation at Aarhus 2025 on Internet ecology, proposing AI-driven software diversity to fight protocol ossification and create more resilient networks.
Mark Elvers. I’ve taken a few days off, and while I’ve been travelling, I’ve been working on a personal project with Claude. I’ve used Claude Code for the first time, which is a much more powerful experience than using claude.ai as Claude can apply changes to the code and use your build tools directly to…
Sadiq Jaffer. I stumbled onto terminal-bench a few weeks ago while researching datasets to evaluate agents. It contains around 120 tasks that need to be completed using a terminal..
Jon Ludlam. LLMs are proving themselves superbly capable of a variety of coding tasks, having been trained against the enormous amount of code, tutorials and manuals available online. However, with smaller langua...
Mark Elvers. I previously wrote about a mtelvers/package-tool which would generate Dockerfiles for each package in opam.
The Tangled git forge has recently gained support for CI, stacked pull requests and also the Dune build system can generate Tangled metadata easily now for OCaml packages hosted there.
Patrick Ferris. Irmin is an OCaml library for building branchable and mergeable data stores. The data is mergeable in the sense of mergeable replicated data types. I have been using Irmin for over five years to build different kinds of interesting data stores including: A simple markdown-based note-taking web appli…
Anil Madhavapeddy, David J. Scott et al. — Proceedings of ACM Programming Languages
Anil Madhavapeddy, Sam Reynolds et al. — Proceedings of the sixth decennial Aarhus conference: Computing X Crisis
Ryan Gibb. Aug. 2025Anil Madhavapeddy, David J. Scott, Patrick Ferris, Ryan T. Gibb, and Thomas Gazagnaire.Proc. ACM Program. Lang. Docker is a developer tool used by millions of developers to build, share and run software stacks. The Docker Desktop clients for Mac and Windows have long used a novel combinatio…
Mark Elvers. I have a dataset that I would like to visualise using a static website hosted on GitHub Pages. The application that generates the dataset is still under development, which results in frequently changing data formats. Therefore, rather than writing a static website generator and needing to revise it …
Patrick Ferris. A short, explanatory post about combining two very fun pieces of work in OCaml. Paul-Elliot has been building Slipshow for some time now where slides are slips and your presentations run vertically. More recently, Arthur has built x-ocaml, a web component library for executable OCaml cells embedded …
Mark Elvers. Would you like to build every package in opam in a single Dockerfile using BuildKit?
Community efforts to improve agentic coding experience for OCaml including MCP libraries, opam embeddings, and tooling improvements.
Patrick Ferris. Thanks to Tarides sponsorship, I get to work on open-source OCaml. This quarterly is a companion to my weeklies, summarising the last three months of development, peppered with ideas and thoughts about OCaml, its community and its future. What I wanted to work on? There were two main things I hoped …
Mark Elvers. Jon asked me to make a Docker image that contains OxCaml ready to run without the need to build it from scratch.
Jon Ludlam. Astonishingly, it's already been since starting back at the university, which I find incredibly hard to believe. I'm utterly convinced that it was only a couple of weeks ago that I walked back into t...
Sadiq Jaffer. A look at recent OCaml projects, from benchmarking AI code models and building new agentic tools to improvements in the garbage collector.
Patrick Ferris. Ppxlib I met with Nathan this week to discuss future plans for ppxlib. The current state of affairs is that ppxlib is becoming unmaintainable. This is primarily a knock-on effect from changes being made to OCaml's parsetree (e.g. labelled tuples being added in 5.4). Nathan has a plan that will provi…
Jon Ludlam. As of today, Odoc 3 is now live on OCaml.org! This is a major update to odoc, and has brought a whole host of new features and improvements to the documentation pages.
Mark Elvers. When working across machines, it’s easy to make changes and reconcile them using git. However, I made a mistake and inadvertently ran dune fmt and now my git diff is a total mess.
Ryan Gibb. Jul. 2025Josh Millar, Ryan Gibb, Roy Ang, Anil Madhavapeddy, and Hamed Haddadi.Preprint. Physical spaces are increasingly dense with networked devices, promising seamless coordination and ambient intelligence. Yet today, cloud-first architectures force all communication through wide-area networks re…
Mark Elvers. In my OCaml project, I’d like to abstract away the details of running containers into specific modules based on the OS. Currently, I have working container setups for Windows and Linux, and I’ve haphazardly peppered if Sys.win32 then where I need differentiation, but this is OCaml, so let us use…
Mark Elvers. Most of the time, you don’t think about how your file is linked. We’ve come to love dynamically linked files with their small file sizes and reduced memory requirements, but there are times when the convenience of a single binary download from a GitHub release page is really what you need.
Mark Elvers. This morning, Anil proposed that having an opam-repository that didn’t have old versions of the packages that require patches to work with OxCaml would be good.
Mark Elvers. The tricky part of using runhcs has been getting the layers correct. While I haven’t had any luck, I have managed to created Windows containers using ctr and containerd.
Mark Elvers. As @dra27 suggested, I first added support in ocurrent/ocaml-version. I went with the name flambda2, which matched the name in the opam package.
Jon Ludlam. Some brief notes on last week.
Mark Elvers. In the week, Jon mentioned UTM, which uses Apple’s Hypervisor virtualisation framework to run ARM64 operating systems on Apple Silicon. It looked awesome, and the speed of virtualised macOS was fantastic. It also offers x86_64 emulation; we mused how well it would perform running Windows, but foun…
Report from NAS/Royal Society forum on standardized biodiversity measurement technologies covering foundation models, eDNA and evidence synthesis.
Patrick Ferris. This week included some time finishing opentrace and subsequently folding it into shelter. I have been writing up some more of the draft paper for shelter which I am excited to share in the near future. I revisited the upgrading vpnkit PR and pushed some more fixes. I have been thinking, again, abou…
Ryan Gibb, Patrick Ferris et al.
Ryan Gibb. Jun. 2025Ryan Thomas Gibb, Patrick Ferris, David Allsopp, Michael Winston Dales, Mark Elvers, Thomas Gazagnaire, Sadiq Jaffer, Thomas Leonard, Jon Ludlam, and Anil Madhavapeddy.Working paper. Package managers are everywhere, with seemingly every language and operating system implementing their own s…
Jon Ludlam. The docs build is progress well, and we've hit 20,000 packages (20,038 to be precise). So at this point I thought it'd be useful to take a look through the various failures to see if there are any in...
Mark Elvers. On the eve of the release of opam 2.4, is it time to stop testing with opam < 2.2?
Mark Elvers. Arthur mentioned that it would be great to know which packages build successfully with OxCaml and which don’t.
Patrick Ferris. I missed a week of posting last week, mainly because I spent more time writing posts. Hazel of OCaml I mentioned previously that I was building a tool to transpile OCaml code to Hazel. This work is now in a good enough state that, along with one of my students, we have transpiled a good number of OC…
Patrick Ferris. This week, I have been trying out Janestreet's Oxidised OCaml (see their ICFP paper). This adds a system of modes to OCaml for expressing things like locality. ...we’re introducing a system of modes, which track properties like the locality and uniqueness of OCaml values. Modes allow the compiler …
Mark Elvers. The log from an OBuilder job starts with the steps needed to reproduce the job locally. This boilerplate output assumes that all OBuilder jobs start from a Docker base image, but on some operating systems, such as FreeBSD and macOS, OBuilder uses ZFS base images. On OpenBSD and Windows, it uses QEMU…
Jon Ludlam. My colleague and I have been working on a little project to see how well small AI models can solve the OCaml exercises we give to our first-year students at the University of Cambridge. Sadiq has don...
Sadiq Jaffer. How well can locally-runnable language models handle OCaml code generation? We evaluate 19 open-weight LLMs on first-year Computer Science exercises, exploring the balance between model size, architecture, and reasoning capabilities for less mainstream programming languages.
Patrick Ferris. Over the past few months, I have been piecing together a transpiler from Hazel to OCaml. This is, in part, to help one of my third-year undergraduate students who is working on type error debugging in Hazel. Typed Holes Hazel is a functional programming language with typed holes. Holes are pieces of…
Jon Ludlam. I joined the OxCaml weekly meeting representing Tarides for the first time this week, as Jane Street gear up to an official release of their OxCaml compiler.
Sadiq Jaffer. Introducing opam-archive-dataset: a Parquet dataset containing code from OCaml packages, designed to improve performance of language models for OCaml development through better training data
Jon Ludlam. The release of Odoc 3 means that we need to update the project so that the documentation that appears on is using the latest, greatest Odoc. With this major release of Odoc, it's also time to give t...
Mark Elvers. As noted on Thursday, the various OCaml services will need to be moved away from Equinix. Below are my notes on moving OCaml-CI.
Ryan Gibb. On 22 Apr 2022, three years ago, I opened an issue in the OCaml package manager, opam, ‘depext does not support nixOS’. Last week, my pull request fixing this got merged! Let’s Encrypt Example Before, if we tried installing an OCaml package with a system dependency we would run into: $ opam --…
Jon Ludlam. Odoc 3 was and although we did write a list of the new features, I don't think we've made it clear enough why anyone should care.
Mark Elvers. Yesterday, we were talking about extending the current infrastructure database to incorporate other information to provide prompts to return machines to the pool of resources after they have completed their current role/loan, etc. There is also a wider requirement to bring these services back to Cam…
Mark Elvers. Late last week, @MisterDA added Fedora 42 support to the Docker base image builder. The new base images attempted to build over the weekend, but there have been a few issues!
Ryan Gibb. I tried using Claude Code while writing Caledonia, and these are the notes I took on the experience. It’s possible some of the deficiencies are due to the model’s smaller training set of OCaml code compared to more popular languages, but there’s work being done to improve this situation. It ne…
Ryan Gibb. A programmable nameserver
Ryan Gibb. A universal dependency solver
Ryan Gibb. Self-hosted digital islands
Jon Ludlam. is a lovely and simple idea that, if it were reliably implemented everywhere, would make life a lot simpler. So, is it possible to make our OCaml libraries stick to this scheme? There are some projec...
Mark Elvers. Over the weekend, I decided to extend my Box tool to incorporate file upload. There is a straightforward POST API for this with a curl one-liner given in the Box documentation. Easy.
Mark Elvers. Previously, I discussed the installation order for a simple directed acyclic graph without any cycles. However, opam packages include post dependencies. Rather than package A depending upon B where B would be installed first, post dependencies require X to be installed after Y. The post dependencies…
Mark Elvers. Given a list of packages and their dependencies, what order should those packages be installed in?
Mark Elvers. After Thomas’ talk today I wanted to try Irmin for myself.
Jon Ludlam. There are that Odoc 3 brings, but there are also a large number of bugfixes. I thought I'd write about one in particular here, an that landed in May 2024.
Jon Ludlam. Back in 2021 introduced some to odoc’s code blocks to allow us to attach arbitrary metadata to the blocks. We imposed no structure on this; it was simply a block of text in between the language ta...
OCaml users: share your needs regarding older versions to help determine support for OCaml 4.08 and earlier.
Claude Code auto-generates OCaml bindings, but lacks robust sandboxing.
Patrick Ferris. VPNKit is a core part of the Docker for Mac/Windows stack. It is tasked with translating network activity from the host to the Linux container. This short post discusses some of the recent changes to MirageOS and how they impact VPNKit. Dune Virtual Libraries Dune, for quite some time, has supported…
Patrick Ferris. Ppxlib is a libary for building OCaml preprocessors. Users can generate OCaml code from OCaml code (derivers) or replace parts of OCaml code with other OCaml code (rewriters). At the core of ppxlib is the OCaml parsetree; a data structure in the compiler that represents OCaml source code. Ppxlib mak…
Learn FPGA programming with OCaml using HardCaml.
Publish custom OCaml Homebrew taps with a simple GitHub workflow.
Learn about my sixth generation oxidised website built with a bleeding-edge OCaml variant.
Michael Dales, Patrick Ferris et al. — 1st International Workshop on Low Carbon Computing
Josh Millar, Sarab Sethi et al.
Thibaut Mattio, Anil Madhavapeddy et al. — proceedings of the 2023 OCaml Users and Developers Workshop
Reviewing OCaml Labs' progress in 2014, covering tooling, compiler, community efforts, and research projects.
MirageOS v2.0 adds ARM support, Irmin storage and OCaml TLS stack.