How Jane Street’s bet on a niche functional language turned into a 30-million-line dependency, and what it teaches us about trading expressiveness for hiring pools.
Most engineers have never written a line of OCaml. Yet every day, a language that barely registers on job boards helps move a meaningful slice of the world’s electronic trading volume. Jane Street, one of the largest market makers on the planet, builds almost everything it ships in OCaml. Not a side project, not a research prototype. Its trading systems, its infrastructure, its internal tools. This is the story of why a proprietary trading firm chose a language nobody was hiring for, what it got in return, and how it solved the one problem that choice should have caused.
A Rewrite That Never Stopped Growing
Jane Street’s relationship with OCaml goes back to the early 2000s, when a small research group inside the firm started experimenting with functional programming as an alternative to the more conventional tools of the time. By 2005, the firm was confident enough to rewrite its core trading systems in OCaml. According to an account published in ACM Queue, the first prototype was trading within six months, and the codebase never looked back.
What followed was two decades of quiet, compounding growth. The numbers tell their own story better than any anecdote can.
By the ocaml.org team’s current account, Jane Street now runs more than 30 million lines of OCaml and employs over 500 OCaml programmers, making it by far the largest industrial user of the language anywhere. Along the way, the firm has also become one of the biggest contributors to the OCaml ecosystem itself, funding the compiler team and releasing widely used tools like the Dune build system and the Core standard library.
Why Expressiveness Wins in a Trading System
Financial systems live and die on correctness under pressure. A trading engine that silently mishandles an edge case does not fail loudly with a stack trace. It fails quietly, and it can fail expensively. This is the environment where OCaml’s strict, expressive type system earns its keep.
OCaml pushes a lot of the work that other languages leave to runtime testing into the compiler itself. Its algebraic data types make it natural to model a trading instrument, an order state, or a settlement outcome so precisely that an entire category of invalid state simply cannot be represented. Combine that with pattern matching that forces every case to be handled, and a whole class of the bugs that show up in production elsewhere gets caught before the code ever runs. That does not eliminate mistakes, but it shifts many of them earlier and cheaper in the development cycle, which matters enormously when the cost of a bug is measured in dollars per microsecond.
None of this is unique to OCaml. Haskell, F#, and Rust all offer versions of the same idea. What made OCaml the right fit for Jane Street specifically was a combination of a mature, predictable compiler, native code performance close to C, and a syntax that turned out to be approachable for people with no functional programming background at all, a point the firm has made repeatedly in its own writing.
The Hiring Pool Problem
Here is the tradeoff every team weighing a niche language eventually runs into. The more expressive and specialized the tool, the smaller the pool of people who already know it, and the harder it becomes to hire at scale. OCaml sits at an extreme end of that spectrum. Looking at UK job market data gives a sense of just how extreme.
| Language | Share of all UK permanent tech jobs | Median advertised salary |
|---|---|---|
| Java | ~6% | ~£72,500 |
| Rust | 0.59% | £90,000 |
| Haskell | 0.036% (UK excl. London) | £55,000 |
| OCaml | 0.005% | £115,000 |
Source: IT Jobs Watch, six-month windows through mid to late 2025. Small absolute counts, particularly for OCaml and Haskell, mean these figures should be read as directional rather than precise.
The pattern is hard to miss. Job postings citing OCaml are so rare that IT Jobs Watch counted a total of three permanent UK vacancies in the six months to mid-2025. And yet the median salary attached to those few postings was the highest of any language in the table. This is the classic scarcity premium: when almost nobody can do the job, the few who can command a price for it. But it also means that if Jane Street tried to hire the way most companies do, by posting a job and waiting for OCaml experts to apply, it would run out of candidates almost immediately.
Solving Scarcity by Refusing to Require the Skill
Jane Street’s actual answer to the hiring pool problem is refreshingly blunt: stop treating OCaml fluency as a prerequisite. The firm states plainly on its own interviewing page that most of the software engineers it hires arrive with no OCaml or functional programming experience at all, and candidates are actively discouraged from trying to learn OCaml just to impress interviewers. Coding interviews are done in whatever language the candidate already knows best.
What closes the gap is what happens after the offer is signed. New engineering hires go through months of internal training and team rotations before settling into a permanent role, and the firm runs a dedicated four-week “OCaml Bootcamp” that brings incoming traders and non-engineering staff up to speed on the language and its tooling, according to the company’s own engineering blog. In effect, Jane Street decoupled the hiring funnel from the language entirely. It hires for raw programming ability and curiosity, then builds the OCaml fluency in-house.
Why this works at Jane Street’s scale but rarely elsewhere:
- A large, well-funded internal training pipeline that most companies cannot replicate
- A reputation and compensation package strong enough to attract talent willing to learn an unfamiliar language on the job
- Decades of internal tooling, libraries, and documentation that shorten the learning curve for new hires
- A codebase large and mature enough that the language’s early productivity cost has long since been repaid
This is not a strategy every engineering organization can copy. It requires the scale, budget, and patience to treat language fluency as something you manufacture rather than something you buy on the open market. For a smaller team, the same bet on a niche language could just as easily become a bottleneck instead of an advantage.
What We Have Learned
Jane Street’s OCaml story is less about one language being objectively superior and more about a company recognizing where its real bottleneck was likely to appear, and designing around it years in advance. The firm bet on a language that gave it stronger correctness guarantees and a highly productive team of specialists, then neutralized the hiring risk that usually comes bundled with that choice by building its own pipeline for turning generalists into OCaml engineers. The lesson for other teams is not “go use OCaml.” It is that the expressiveness-versus-hiring-pool tradeoff is real, but it is not fixed. It can be engineered around, provided you are honest about the cost of doing so and have the resources to pay it.
