“0xCaml From a System Engineer's Point of View”

Dmitriy Kovalenko; Talk

I do a lot of Rust, C, Zig and whatever else cursed systems programming languages are there. So recently 0xCaml popped out and I was def interested if I can finally use it. So I did some research on how it actually works comparing to native OCaml and other languages and try to build odiff (the fastest image comparison lib in the world) with 0xCaml. Here is what I learned.

“Analyzing Programs with SMT Solvers”

Tikhon Jelvis; Talk

We can use SMT solvers like Z3 to analyze programs and answer
difficult questions about our code. By generating and solving complex
constraints, we can improve error message localization, attack
cryptographic protocols, check refinement types, search for proofs,
verify invariants, compare programs against specifications or even
synthesize code. Z3 is the goto state-of-the-art SMT solver, available
under and open source license and has a first-class OCaml library.

In this talk, I'll walk through a simple OCaml program to generate SMT
constraints that represent a bounded model of programs in a simple
imperative language. Algebraic data types and pattern matching are a
perfect fit for this kin

“Build Language Models with Raven”

Thibaut Mattio; Workshop

Discover how to build and train language models using OCaml with Raven, a modern scientific
computing ecosystem that brings JAX-like capabilities to functional programming. This hands-on
workshop introduces Raven's key libraries-Nx for tensor operations, Rune for automatic
differentiation and JIT compilation, and Kaun for neural network architectures-demonstrating how to
implement transformer-based models with type safety and competitive performance.

We'll explore Rune's effect-based autodiff system, implement attention mechanisms, and train a
small language model while leveraging OCaml's type system for production-ready ML systems.

“Cross-Platform OCaml Projects”

Manas Jayanth; Talk

OCaml ecosystem contains many platform specific packages. While working on a project, a developer may not realise if the packages in the transitive closure are portable or platform specific. At the same time, knowing the complete set of dependencies (transitively) is also important for reproducibility reasons. How do we make sure such lock files work on different machines, say both on MacOS Silicon as well as Windows x64?

In this talk, we try to understand the problem, resources at our disposal, and how I implemented portable lock files for esy, the package manager for Reason and OCaml.

“Frameworks: No, Libraries: Yes. Developing a Product in OCaml From Scratch”

Malcolm Matalka; Talk

Terrateam is an open source infrastructure management product written in OCaml. In order to stay lean and flexible, Terrateam has developed almost all of its own frameworks and tooling. With a small team, the Terrateam product punches well above its weight compared to its competition. This talk will cover the choice to develop their own frameworks, the good, the bad, and how OCaml has been instrumental in being able to achieve so much despite being a two person company.

“From OCaml 4 to 5 and from Parmap to Effects: A legacy code transition story”

Nat Mote, Nathan Taylor; Talk

OCaml 5's support for shared memory parallelism and effects-based concurrency opens up new ways for developers to build new OCaml programs for modern hardware, but it isn't trivial to migrate existing software to this new world. We've spent the last few months porting a large (~3MM LoC) OCaml codebase from process-based parallelism to multi-domain Eio, and learned a lot along the way. In this talk, we'll discuss the fundamentals of shared-memory parallism, our incremental migration approach which used a combination of static and dynamic analysis, the pitfalls (both expected and unexpected) that we encountered along the way, and some lessons that others can adopt for their own journey.

“Generating Static Websites the Functional Programming Way”

Xavier Van de Woestyne; Talk

Static site generators like Jekyll, Zola, and Hugo are effective, but fall short for complex sites like personal encyclopedias, wikis, or sites with rich content. Features like backlinks and transclusions require richer context and efficient builds. This talk explores the theory behind static site generation (as a case of build systems) and shows how to implement advanced features inspired by Project Xanadu using YOCaml, a static site framework based on functional abstractions (such as strong profunctors) in OCaml.

“I Can See The Pixels: Designing Cross-Stitch Patterns in OCaml”

yomimono; Talk

I was unsatisfied with existing cross-stitch pattern generating software, which was mostly structured like pixel-based paint programs. Those programs with support for very common operations like tiling borders were locked behind paywalls. I decided to write my own in OCaml, and I've been using it to design cross-stitch patterns since 2019. I'll talk a bit about the joy of making the Exact Right Tool, the anguish of abandoned experiments, and the ambiguous pleasure of monetizing art.

“mlx, Melange, React and Server Components”

David Sancho Moreno; Workshop

An interactive workshop exploring a powerful technology stack that bridges functional programming with modern web development. We'll demonstrate how OCaml-based tools integrate seamlessly with React to create robust, type-safe applications.

• We will use mlx (an OCaml syntax that adds JSX into the language)
• Hands-on exploration of Melange single context and other patters of universal libraries
• Explaining what's React server components
• and implementing a small app

“OCaml at LexiFi”

Nicolas Ojeda Bär; Talk

LexiFi is likely to have been the first real industrial user of OCaml, back when it was funded in 2000. In this talk, I will present some of the things we have learned along the way. Some of the points I will address: our technology stack (development environment, deployment and distribution, cloud infrastructure, etc), tooling, strong and weak points of OCaml, people aspects (hiring and training), etc. If there is time, I will also present one of our key technical innovations: extending the OCaml compiler with type reflection (this topic will be explored further in the dedicated Workshop).

“OCaml Compiler Hacking: Type Reflection”

Nicolas Ojeda Bär; Workshop

At LexiFi, we maintain a fork of the official OCaml compiler extended with support for type reflection. This is an powerful approach that largely supplants and improves on PPX for many tasks.

While our fork is not open source, the approach using type reflection deserves to be better known. With that in mind, this workshop will explain some of the main ideas involved by implementing a toy version of type reflection in the upstream compiler. Participants will be assumed to be conversant in OCaml but not to have any prior experience with compilers/types/etc and anyone interested in getting started hacking the OCaml compiler is welcome to come!

“OCaml Observability with OpenTelmetry”

Austin Theriault; Workshop

Semgrep has significantly scaled their titular product written in OCaml, and telemetry has been a critical element in doing so. In this talk we want to first give a brief introduction to telemetry and how and when to use different types of telemetry. Next we will present on how to use different parts of the OCaml OpenTelemetry library, how we use them, and demo some real life examples. Finally we will cover how adding this telemetry has helped our business scale.

“Performance Pitfalls: Tales From a Python/OCaml Codebase”

Emma Jin; Talk

Semgrep is a tool that enables developers to search their code for security vulnerabilities, built with an OCaml engine and a Python frontend. This has come with a fair amount of performance pain. In this talk, I'll share some of the worst problems we ran into, how we found them, and how we solved them (mostly, rewriting Python code in OCaml).

“Slipshow: A Full-Featured Presentation Tool in OCaml”

Paul-Elliot Anglès d'Auriac; Talk

Slipshow is a tool to create interactive presentations. Started as a JavaScript project, it is now fully written in OCaml and features a runtime engine, a compiler, a collaborative editing website, a VSCode extension, a standalone app...

This talk tells the story of how it is possible to develop and maintain such a challenging project as a single developer.

If you are reading this far into the abstract, I suspect you are going to FUN OCaml? Are you giving a talk? If so, consider (re)writing your presentation in Slipshow!

“State of the OCaml Ecosystem 2025”

Leandro Ostera; Talk

This talk breaks down how the OCaml ecosystem is actually growing by digging into real GitHub data - repo activity, contributor trends, and which libraries are gaining traction. We'll look at the numbers behind OCaml's momentum and what they tell us about where the community and tooling are headed in 2025.

“Train a Reinforcement Learning Agent for the Box-Pushing Game Sokoban in OCANNL or Raven”

Lukasz Stafiniak; Workshop

I will give a very brief intro to Reinforcement Learning (RL), covering just the REINFORCE algorithm. We will build an RL harness and an environment for the Sokoban game (cheating allowed). We will program and train models using a convolutional neural net or an axial-attention transformer. While the nets are training, I will introduce the Group Relative Policy Optimization (GRPO) algorithm and discuss how our agent setup relates to post-training of language models on solving problems. Time permitting, we would then implement GRPO and compare its performance with REINFORCE.

“Vif & Hurl, a Web Framework for OCaml 5”

Calascibetta Romain; Workshop

The aim of this workshop is to present Vif, a new typed web framework for OCaml 5. We will introduce Vif to participants through a practical example: a user space with a chat room, which we will develop into a web application. We will test this application using hurl, an HTTP client in OCaml. We will see typed routes, typed forms, typed SQL queries (thanks to caqti) as well as websockets (and of course, js_of_ocaml). More importantly, participants will also be able to give feedback on our framework (and perhaps participate in its development) in order to improve it and bring web development back to the world of OCaml 5 and types!