Tarides: 2024 in Review

At Tarides, we believe in making OCaml a mainstream programming language by improving its tooling and integration with other successful ecosystems. In 2024, we focused our efforts on initiatives to advance this vision by addressing key technical challenges and engaging with the community to build a stronger foundation for OCaml’s growth. This report details our work, the rationale behind our choices, and the impact achieved. We are very interested in getting your feedback: please get in touch (or respond to the Discuss thread) if you believe we are going in the right direction.

TL;DR – In 2024, Tarides focused on removing adoption friction with better documentation and tools; and on improving adoption via the integration with three key thriving ecosystems: multicore programming, web development, and Windows support. Updates to ocaml.org improved onboarding and documentation, while the Dune Developer Preview simplified workflows with integrated package management. Merlin added support for project-wide reference support and odoc 3, which is about to be released. OCaml 5.3 marked the first stable multicore release, and js_of_ocaml achieved up to 8x performance boosts in real-world commercial applications thanks to added support for WebAssembly. On Windows, opam 2.2 brought full compatibility and CI testing to all Tier 1 platforms on opam-repository, slowly moving community packages towards reliable and better support for Windows. Tarides’ community support included organising the first FUN OCaml conference, many local meetups, and two rounds of Outreachy internships.

Better Tools: Toward a 1-Click Installation of OCaml

Our primary effort in 2024 was to continue delivering on the OCaml Platform roadmap published last year. We focused on making it easier to get started with OCaml by removing friction in the installation and onboarding process. Our priorities were guided by the latest OCSF User Survey, direct user interviews, and feedback gathered from the OCaml community. Updates from Tarides and other OCaml Platform maintainers were regularly shared in the OCaml Platform Newsletter.

OCaml.org

OCaml.org is the main entry point for new users of OCaml. Tarides engineers are key members of the OCaml.org team. Using privacy-preserving analytics, the team tracked visitor behaviour to identify key areas for improvement. This led to a redesign of the installation page, simplifying the setup process, and a revamp of the guided tour of OCaml to better introduce the language. Both pages saw significant traffic increases compared to 2023, with the installation page recording 69k visits, the tour reaching 65k visits and a very encouraging total number of visits increasing by +33% between Q3 and Q4 2024

Efforts to improve user experience included a satisfaction survey where 75% of respondents rated their experience positively, compared to 17% for the previous version of the site. User testing sessions with 21 participants provided further actionable insights, and these findings informed updates to the platform. The redesign of OCaml.org community sections was completed using this feedback. It introduced several new features: a new Community landing page, an academic institutions page with course listings, and an industrial users showcase. The team also implemented an automated event announcement system to inform the community of ongoing activities.

Progress and updates were regularly shared through the OCaml.org newsletters, keeping the community informed about developments. Looking ahead, the team will continue refining the platform by addressing feedback, expanding resources, and monitoring impact through analytics to support both new and experienced OCaml users. Lastly, the infrastructure they build is starting to be used by other communities: Rocq just announced their brand new website, built using the same codebase as ocaml.org!

Dune as the Default Frontend of the OCaml Platform

One of the main goals of the OCaml Platform is to make it easier for users—especially newcomers—to adopt OCaml and build projects with minimal friction. A critical step toward this goal is having a single CLI to serve as the frontend for the entire OCaml development experience (codenamed Bob in the past). This year, we made significant progress in that direction with the release of the Dune Developer Preview.

Setting up an OCaml project currently requires multiple tools: opam for package management, dune for builds, and additional installations for tools like OCamlFormat or Odoc. While powerful, this fragmented workflow can make onboarding daunting for new users. The Dune Developer Preview consolidates these steps under a single CLI, making OCaml more approachable. With this preview, setting up and building a project is as simple as:

1. dune pkg lock to lock the dependencies.
2. dune build to fetch the dependencies and compile the project.

This effort is also driving broader ecosystem improvements. The current OCaml compiler relies on fixed installation paths, making it difficult to cache and reuse across environments, so it cannot be shared efficiently between projects. To address this, we are working on making the compiler relocatable (ongoing work). This change will enable compiler caching, which means faster project startup times and fewer rebuilds in CI. As part of this effort, we also maintain patches to core OCaml projects to make them relocatable – and we worked with upstream to merge (like for ocamlfind). Tarides engineers also continued to maintain Dune and other key Platform projects, ensuring stability and progress. This included organising and participating in regular development meetings (for Dune, opam, Merlin, ppxlib, etc.) to prioritise community needs and align efforts across tools like Dune and opam to avoid overlapping functionality.

The Dune Developer Preview is an iterative experiment. Early user feedback has been promising (the Preview’s NPS went from +9 in Q3 2024 to +27 in Q4 2024), and future updates will refine the experience further. We aim to ensure that experimental features in the Preview are upstreamed into stable releases once thoroughly tested. For instance, the package management feature is already in Dune 3.17. We will announce and document it more widely when we believe it is mature enough for broader adoption.

Editors

In 2024, Tarides focused on improving editor integration to lower barriers for new OCaml developers and enhance the experience for existing users. Editors are the primary way developers interact with programming languages, making seamless integration essential for adoption. With more than 73% of developers using Visual Studio Code (VS Code), VS Code is particularly important to support, especially for new developers and those transitioning to OCaml. As part of this effort, Tarides wrote and maintained the official VS Code plugin for OCaml, prioritising feature development for this editor. We also support other popular editors like Emacs and Vim—used by many Tarides engineers—on a best-effort basis. Improvements to OCaml-LSP and Merlin, both maintained by Tarides, benefit all supported editors, ensuring a consistent and productive development experience.

While several plugins for OCaml exist (OCaml and Reason IDE–128k installs, Hackwaly–90k installs), our OCaml VS Code plugin –now with over 208k downloads– is a key entry point for developers adopting OCaml in 2024. This year, we added integration with the Dune Developer Preview, allowing users to leverage Dune's package management and tooling directly from the editor. Features such as real-time diagnostics, autocompletion, and the ability to fetch dependencies and build projects without leaving VS Code simplify development and make OCaml more accessible for newcomers.

The standout update in 2024 was the addition of project-wide reference support, a long-requested feature from the OCaml community and a top priority for commercial developers. This feature allows users to locate all occurrences of a term across an entire codebase, making navigation and refactoring significantly easier—especially in large projects. Delivering this feature required coordinated updates across the ecosystem, including changes to the OCaml compiler, Merlin, OCaml LSP, Dune, and related tools. The impact is clear: faster navigation, reduced cognitive overhead, and more efficient workflows when working with complex projects.

Additional improvements included support for new Language Server Protocol features, such as signature_help and inlay_hint, which enhance code readability and provide more contextual information. These updates enabled the introduction of new commands, such as the "Destruct" command. This little-known but powerful feature automatically expands a variable into a pattern-matching expression corresponding to its inferred type, streamlining tasks that would otherwise be tedious.

Documentation

Documentation was identified as the number one pain point in the latest OCSF survey. It is a critical step in the OCaml developer journey, particularly after setting up the language and editor. Tarides prioritised improving odoc to make it easier for developers to find information, learn the language, and navigate the ecosystem effectively. High-quality documentation and tools to help developers get "unstuck" are essential to reducing friction and ensuring a smooth adoption experience.

Tarides is the primary contributor and maintainer of odoc, OCaml’s main documentation tool. In preparation for the odoc 3 release, our team introduced two significant updates. First, the odoc Search Engine was integrated, allowing developers to search directly within OCaml documentation via the Learn page. Second, the odoc Cheatsheet provides a concise reference for creating and consuming OCaml documentation. We would like to believe that these updates, deployed on ocaml.org, were the main cause of a 45% increase in package documentation usage on https://ocaml.org/pkg/ in Q4 2024!

Another area where developers often get stuck is debugging programs that don’t work as expected. Alongside reading documentation, live debuggers are crucial for understanding program issues. Tarides worked to improve native debugging for OCaml, focusing on macOS, where LLDB is the only supported debugger. Key progress included a name mangling fix to improve symbol resolution, restoring ARM64 backtraces, and introducing Python shims for code sharing between LLDB and GDB.

OCaml’s error messages remain a common pain point, particularly for syntax errors. Unlike Rust’s error index, OCaml does not (yet!) have a centralised repository of error explanations. Instead, we are focused on making error messages more self-explanatory. This requires developing new tools, such as lrgrep, a domain-specific language for analysing grammars built with Menhir. lrgrep enables concise definitions of error cases, making it possible to identify and address specific patterns in the parser more effectively. This provides a practical way to improve error messages without requiring changes to the compiler. In December 2024, @let-def successfully defended his PhD (a collaboration between Inria and Tarides) on this topic, so expect upstreaming work to start soon.

OCaml Package Ecosystem

The last piece of friction we aimed to remove in 2024 was ensuring that users wouldn’t encounter errors when installing a package from the community. This required catching issues early—before packages are accepted into opam-repository and made available to the broader ecosystem. To achieve this, Tarides has built and maintained extensive CI infrastructure, developed tools to empower contributors, and guided package authors to uphold the high quality of the OCaml package ecosystem.

In 2024, Tarides’ CI infrastructure supported the OCaml community at scale, handling approximately 20 million jobs on 68 machines covering 5 hardware architectures. This infrastructure continuously tested packages to ensure compatibility across a variety of platforms and configurations, including OCaml’s Tier 1 platforms: x86, ARM, RISC-V, s390x, and Power. It played a critical role during major events, such as new OCaml releases, by validating the ecosystem’s readiness and catching regressions before they impacted users. Additionally, this infrastructure supported daily submissions to opam-repository, enabling contributors to identify and resolve issues early, reducing downstream problems. To improve transparency and accessibility, we introduced a CI pipeline that automates configuration updates, ensuring seamless deployments and allowing external contributors to propose and apply changes independently.

In addition to maintaining the infrastructure, Tarides developed and maintained the CI framework running on top of it. A major focus in 2024 was making CI checks available as standalone CLI tools distributed via opam. These tools enable package authors to run checks locally, empowering them to catch issues before submitting their packages to opam-repository. This approach reduces reliance on central infrastructure and allows developers to work more efficiently. The CLI tools are also compatible with GitHub Actions, allowing contributors to integrate tests into their own workflows. To complement these efforts, we enhanced opam-repo-ci, which remains an essential safety net for packages entering the repository. Integration tests for linting and reverse dependencies were introduced, enabling more robust regression detection and improving the reliability of the ecosystem.

To uphold the high standards of the OCaml ecosystem, every package submission to opam-repository is reviewed and validated to ensure it meets quality criteria. This gatekeeping process minimises errors users might encounter when installing community packages, enhancing trust in the ecosystem. In 2024, Tarides continued to be actively involved in maintaining the repository, ensuring its smooth operation. We also worked to guide new package authors by updating the contributing guide and creating a detailed wiki with actionable instructions for adding and maintaining packages. These resources were announced on Discuss to reach the community and simplify the process for new contributors, improving the overall quality of submissions.

Playing Better with the Larger Ecosystem

Concurrent & Parallel Programming in OCaml

Twenty+ years after this statement, processors are multicore by default, and OCaml has adapted to this reality. Thanks to the combined efforts of the OCaml Labs and Tarides team, the OCaml 5.x series introduced multicore support after a decade of research and experimentation. While this was a landmark achievement, the path to making multicore OCaml stable, performant, and user-friendly has required significant collaboration and continued work. In 2024, Tarides remained focused on meeting the needs of the broader community and commercial users.

OCaml 5.3 (released last week) was an important milestone in this journey. With companies such as Routine, Hyper, and Asemio adopting OCaml 5.x, and advanced experimentation ongoing at Jane Street, Tezos, Semgrep, and others, OCaml 5.3 is increasingly seen as the first “stable” release of the multicore series. While some performance issues remain in specific parts of the runtime, we are working closely with the community to address them in OCaml 5.4. Tarides contributed extensively to the 5.2 and 5.3 releases by directly contributing to nearly two-thirds of the merged pull requests. Since Multicore OCaml was incorporated upstream in 2023, we have been continuously involved in the compiler and language evolution in collaboration with Inria and the broader OCaml ecosystem.

Developing correct concurrent and parallel software is inherently challenging, and this applies as much to the runtime as to applications built on it. In 2024, we focused on advanced testing tools to help identify and address subtle issues in OCaml’s runtime and libraries. The property-based test suite reached maturity this year, uncovering over 40 critical issues, with 28 resolved by Tarides engineers. Trusted to detect subtle bugs, such as issues with orphaned ephemerons, the suite has become an integral part of OCaml’s development workflow. Importantly, it is accessible to contributors without deep expertise in multicore programming, ensuring any changes in the compiler or the runtime do not introduce subtle concurrency bugs.

Another critical effort was extending ThreadSanitizer (TSAN) support to most Tier 1 platforms and applying it extensively to find and fix data races in the runtime. This work has improved the safety and reliability of OCaml’s multicore features and is now part of the standard testing process, further ensuring the robustness of the runtime.

Beyond testing, we also worked to enhance library support for multicore programming. The release of the Saturn library introduced lock-free data structures tailored for OCaml 5.x. To validate these structures, we developed DSCheck, a static analyser for verifying lock-free algorithms. These tools, along with Saturn itself, provide developers with reliable building blocks for scalable multicore applications.

Another promising development in 2024 was the introduction of the Picos framework. Picos aims to provide a low-level foundation for concurrency, simplifying interoperability between libraries like Eio, Moonpool, Miou, Riot, Affect, etc. Picos offers a simple, unopinionated, and safe abstraction layer for concurrency. We believe it can potentially standardise concurrency patterns in OCaml, but we are not there yet. Discussions are underway to integrate parts of Picos into higher-level libraries and, eventually, the standard library. We still have a long way to go, and getting feedback from people who actively tried it in production settings would be very helpful!

Web

Web development remains one of the most visible and impactful domains for programming languages; JavaScript, HTML, and CSS are the most popular technologies in 2024. For OCaml to grow, it must integrate well with this ecosystem. Fortunately, the OCaml community has already built a solid foundation for web development!

On the frontend side, in 2024, Tarides focused on strengthening key tools like js_of_ocaml by expanding its support for WebAssembly (Wasm). js_of_ocaml (JSOO) has long been the backbone of OCaml’s web ecosystem, enabling developers to compile OCaml bytecode into JavaScript. This year, we merged Wasm support back into JSOO, unifying the toolchain and simplifying adoption for developers. The performance gain of Wasm has been very impressive so far: CPU-intensive applications in commercial settings have seen 2x to 8x speedups using Wasm compared to traditional JSOO. We also worked on better support for effect handlers in js_of_ocaml to ensure applications built with OCaml 5 can run as fast in the browser as they used to with OCaml 4.

On the backend side, Tarides maintained and contributed to Dream, a lightweight and flexible web framework. Dream powers projects like our own website and the MirageOS website, where we maintain a fork to make Dream and MirageOS work well together. Additionally, in 2024, we enhanced cohttp, adding proxy support to address modern HTTP requirements.

While Tarides focused on JSOO, wasm_of_ocaml, Dream, and Cohttp, the broader community made significant strides elsewhere. Tools like Melange offer an alternative for compiling OCaml to JavaScript, and frameworks like Ocsigen, which integrates backend and frontend programming, continue to push the boundaries of what’s possible with OCaml on the web. Notably, Tarides will build on this momentum in 2025 through a grant to improve direct-style programming for Ocsigen.

Windows

Windows is the most widely used operating system, making first-class support for it critical to OCaml’s growth. In 2024, 31% of visitors to ocaml.org accessed the site from Windows, yet the platform’s support historically lagged behind Linux and macOS. This gap created barriers for both newcomers and commercial users. We saw these challenges firsthand, with Outreachy interns struggling to get started due to tooling issues, and commercial users reporting difficulties with workflow reliability and compilation speed.

To address these pain points, Tarides, in collaboration with the OCaml community, launched the Windows Working Group. A key milestone that our team contributed to was the release this year of opam 2.2, three years after its predecessor. This release made the upstream opam-repository fully compatible with Windows for the first time, removing the need for a separate repository and providing Windows developers access to the same ecosystem as Linux and macOS users. The impact has been clear: feedback on the updated installation workflow has been overwhelmingly positive, with developers reporting that it "just works." The install page for Windows is now significantly shorter and simpler!

In the OCaml 5.3 release, Tarides restored the MSVC Windows port, ensuring native compatibility and improving performance for Windows users. To further support the ecosystem, Tarides added Windows machines to the opam infrastructure, enabling automated testing for Windows compatibility on every new package submitted to opam. This has already started to improve package support, with ongoing fixes from Tarides and the community. The results are publicly visible at windows.check.ci.dev, which we run on our infrastructure, providing transparency and a way to track progress on the status of our ecosystem. While package support is not yet on par with other platforms, we believe that the foundations laid in 2024—simplified installation, improved tooling, and continuous package testing—represent a significant step forward.

Community Engagement and Outreach

In 2024, Tarides contributed to building a stronger OCaml community through events, internships, and support for foundational projects. The creation of FUN OCaml 2024 in Berlin was the first dedicated OCaml-only event for a long time (similar to how the OCaml Workshop was separated from ICFP in the past). Over 75 participants joined for two days of talks, workshops, and hacking, and the event has already reached 5k+ views on YouTube. Tarides also co-chaired the OCaml Workshop at ICFP 2024 in Milan, bringing together contributors from academia, industry, and open-source communities. These events brought together two different kinds of OCaml developers (with some overlap), bringing an interesting energy to our community.

To expand local community involvement, Tarides organised OCaml hacking meetups in Manila and Chennai. To make it easier for others to host similar events, we curated a list of interesting hacking issues from past Cambridge sessions, now available on GitHub.

As part of the Outreachy program, Tarides supported two rounds of internships in 2024, with results published on Discuss and watch.ocaml.org. These internships not only provided great contributions to our ecosystem but also brought fresh insights into the challenges faced by new users. For example, interns identified key areas where documentation and tooling could be improved, directly informing future updates.

Tarides also maintained its commitment to funding critical open-source projects and maintainers. We continued funding Robur for their maintenance work on MirageOS (most of those libraries are used by many –including us– even in non-MirageOS context) and Daniel Bünzli, whose libraries like cmdliner are essential for some of our development.

Finally, Tarides extended sponsorships to non-OCaml-specific events, including JFLA, BobConf, FSTTCS, and Terminal Feud (which garnered over 100k views). These events expanded OCaml’s visibility to new audiences and contexts, introducing the language to a broader technical community that –we hope– will discover OCaml and enjoy using it as much as we do.

What’s Next?

As we begin 2025, Tarides remains committed to making OCaml a mainstream language. Our focus this year is to position OCaml as a robust choice for mission-critical applications by enhancing developer experience, ecosystem integration, and readiness for high-assurance use cases.

We aim to build on the Dune Developer Preview to further improve usability across all platforms, with a particular emphasis on Windows, to make OCaml more accessible to a broader range of developers. Simultaneously, we will ensure OCaml is ready for critical applications in industries where reliability, performance, and security are essential. Projects like SpaceOS showcase the potential of memory- and type-safe languages for safety-critical systems. Built on MirageOS and OCaml’s unique properties, SpaceOS is part of the EU-funded Orchide project and aims to set a new standard for edge computing in space. Additionally, SpaceOS is being launched in the US through our spin-off Parsimoni. However, these needs are not limited to Space: both the EU Cyber Resilience Act and the US cybersecurity initiatives highlight the growing demand for type-safe, high-assurance software to address compliance and security challenges in sensitive domains. Tarides believes that OCaml has a decisive role to play here in 2025!

I’d like to personally thank our sponsors and customers, especially Jane Street, for their unwavering support over the years, and to Dennis Dang, our single recurring GitHub sponsor. Finally, to every member of Tarides who worked so hard in 2024 to make all of this happen: thank you. I’m truly lucky to be sailing with you on this journey!

We are looking for sponsors on GitHub, are happy to collaborate on innovative projects involving OCaml or MirageOS and offer commercial services for open-source projects – including long-term support, development of new tools, or assistance with porting projects to OCaml 5 or Windows.