A lot of conservation and planetary computing this week. We celebrated a decade of the CCI with a visit from Sir David Attenborough, and Andrew Balmford delivered his Royal Society Environment Medal lecture. I also tuned in remotely to the third PROPL at PLDI, where the programming-languages community had an action-oriented discussion. On the hacking side, I wrapped a local LLM up as an OCaml library and started fleshing out OCaml/Eio on Windows. Plus fun links at the end.
1 Ten years of the CCI, with Sir David Attenborough
The Cambridge Conservation Initiative turned ten this week, and Sir David Attenborough himself dropped by to celebrate (and narrate a new video, just after his 100th birthday!). I spent the afternoon demoing TESSERA and the freshly renamed Dash of Life (our Enki dashboard) at a campus packed with visitors. The standing ovation when Sir David walked into the Babbage theatre was deafening and very heartwarming.
I've written the day up properly, and it's a splendid reminder of how much gets done in the stairwells and common room of the David Attenborough Building.
2 Feeding the world without costing the earth
Earlier in the week I was down at Carlton House Terrace for the inaugural Royal Society Environment Prize lecture, where Andrew Balmford was awarded the Environment Medal. His talk on "Feeding the world without costing the earth" is a relentlessly data-driven view that many of the conventional pieces of wisdom (like going organic) are all necessary but nowhere near sufficient to arrest biodiversity collapse, and that slowing the extinction crisis hinges on sustainable high-yield farming explicitly tied to land sparing. My full notes and slides are here.
Just before heading down, I also nipped into the Vice Chancellor Debbie Prentice's annual garden party, where I caught up with many friends I hadn't seen in a while! Last year, we were in the middle of a heatwave and the grass was all parched. This year, it almost rained...
3 The third PROPL (programming for the planet)
The third PROPL (Programming for the Planet) was held at PLDI 2026 this week, and since I couldn't be there in person I tuned in virtually and live-tooted over on the @propl.dev Bluesky feed (live-skeeting? sounds a bit silly). We also maintained a collaborative living document where Q&A got recorded and discussions continued.
This edition tried a new format since it came less than a year before the 2nd PROPL. Rather than a full day of talks, we held a morning of position papers followed by an afternoon "working group" aimed at producing concrete action items for what the PL and systems community can actually build together.
Cyrus Omar opened by making the case that the future digital commons for science must not just store data under FAIR principles but must also compute over it. The morning talks were a strong lineup:
- Deepak Cherian (Earthmover) on Icechunk, a cloud-native, chunked, compressed nd-array storage format with version control, isolated transactions and snapshots. A sort of "Git for columnar data", born out of the xarray/netCDF lineage. I chuckled when he said that "the pile-of-files model severely lacks rigor" as we're frantically rsyncing terabytes of Tessera embeddings around. The discussions covered federation (you can only really trust the cloud if there's more than one instance) as this matters for datasets like the GEDI products that get recomputed as calibration improves, so updates can be peer-reviewed rather than silently promoted.
- Billy Moses and a large cast talked about their compiler-first planetary compute engine: they built Enzyme to do automatic differentiation at the LLVM level, and a Reactant frontend that rewrites existing CUDA code into StableHLO so it can target TPUs. Having end-to-end differentiable earth-system models opens the door to calibration, tuning and uncertainty quantification across many large million-line Fortran codebases like MITgcm. One cool example was doing AD on the famous black-hole image which dropped the compute time from over a week to an hour.
- Dominic Orchard then talked about "minding the gap" between the semantic chasm between the mathematical equations in a paper and the code that supposedly implements them. He showed the Fluid literate language and previewed a new statically-typed language he's designing called
fortl, whose types carry units and physical structure (like Camfort's units-of-measure analysis but baked into the type system). - Mark Piper discussed the Basic Model Interface (BMI), a minimal, language-agnostic spec (about ~30 functions) for coupling numerical models, crowdsourced through the CSDMS community.
The afternoon switched to breakout working groups, where the planetary computing agenda ranged over:
- how to bootstrap a computational commons (start small, solve important problems first, build buy-in, and surface the benefits before trying to boil the ocean with a huge software monolith)
- a session on agents-as-collaborators, covering auditability, the climate cost of the models, whether prompt histories should be submitted alongside vibe-coded PRs, and TDD-style processes where verification happens within the workflow rather than after it
- the sociotechnical reality that you can't just get a working scientist ('vernacular programmers') to switch languages; instead we have to meet them where they are, mind the privacy of sensitive data (like endangered-species locations or farmers' fields), and co-design participatively.
I'm glad PROPL is becoming the venue for this kind of discussion! When things calm down after term-time, I'll be working with Dominic Orchard and Cyrus Omar to distill down the detailed working group sessions into a community writeup. Any ideas for the next PROPL and its focus are welcome from anyone interested in participating!
4 Local LLMs as an ordinary OCaml library
I wrote up my local LLM experiment this week. After Fable cut out, I bound the Dwarfstar inference engine into OCaml 5 and Eio as ocaml-deepseek, so a DeepSeek V4 Flash model running locally on my Mac is now a plain OCaml function call away. The agent's tools are ordinary OCaml functions, each sandboxed with Eio capabilities to exactly what it needs.
Shriram Krishnamurthi then followed up by pointing me at Hadley Wickham's piece on how agents actually work under the hood, which kicked off a discussion about how a small algebra of combinators for "agent context control" (composing, scoping and pruning exactly what the model sees at each step) would be rather handy.
I've also just started using GLM 5.2 running locally on my Mac Studio using the mlx-lm per-layer DSA indexer PR which is necessary due to the new model architecture. It works great so far, holding at a cool ~450GB heap size with the Pi agent.
4.1 OpenUK roundtable on sovereign AI
I also attended a session for London Tech Week hosted by Amanda Brock of OpenUK about the importance of sovereign AI. Due to train issues, I had to dial in remotely which was a pity as Mike Bracken (who I last met when I worked for Chello back in ~2000) was there and it would have been great to see him again in person! The writeup of this session is available in Resultsense:
OpenUK chief executive Amanda Brock warned that “data sovereignty”, “digital sovereignty” and “AI sovereignty” are too often conflated, and cautioned that sovereignty cannot be achieved in isolation given open source depends on global collaboration. Red Hat’s Johnny Williams framed it as “agency, choice and control”, warning against “sovereign washing” that fixates on where a supplier is headquartered while overlooking wider dependencies. Arm’s Matthew Crawford argued no single country can control every component of a modern AI model, urging a focus on resilience instead. -- "Can open source deliver sovereign AI? UK experts weigh in"
Another good read this week was an article on how Europe's AI sovereignty problem runs deeper than frontier access. Unfortunately, the EU seems to be making bizarre choices by moving to closed source social media forks of ATProto rather than federated relays like the good folk at Eurosky are already doing.
5 Getting Eio working on Windows
A blocker to getting Docker VPNKit refreshed to the latest Eio is Windows support. So after last week's io_uring spree on Linux, I spent the back half of this week on getting Eio running properly on Windows 11. Windows has a close equivalent to uring called IORing, but before using that I refreshed the bindings to the more traditional I/O completion ports (IOCP). Both bindings should end up looking a lot like the Linux one, I hope.
I reworked the low-level ocaml-iocp bindings and rebuilt the API around a bounded free-list of OVERLAPPED slots. Then in the Eio Windows backend itself I rewrote the scheduler on top of IOCP (modelled on uring's), associating file descriptors with their IOCP port and suspending each fiber until its operation completes. Then it was a matter of splitting I/O dispatch per descriptor so that sockets and pipes go through overlapped IOCP, while regular files and the console run on a systhread pool so they can't stall the event loop. I'm still really confused about how console descriptors work on Windows, so this will spill into next week while I figure this out.
I also added process support (for spawning, capturing stdout/stderr, reading exit status, and passing a custom environment) as well as testing working TCP loopback, socketpairs, pipes, filesystem and timers. Some Windows quirks I noticed:
- Readiness doesn't exist as IOCP only tells you when an operation completed, but never when an FD is ready. So I faked readiness checks with a zero-byte overlapped recv/send, but I wonder if the scheduler structure is incorrectly edge-triggered as a result of needing this hack.
- Closing the read half doesn't wake a blocked read for some reason. Unlike the Linux
SHUT_RD, a WindowsSD_RECEIVEseems to leave an outstanding overlapped recv hanging forever. - A vanished peer surfaces as a raw Win32 code like ERROR_NETNAME_DELETED that isn't in the OCaml runtime's error table, so it has to be translated to a Unix-ish errno.
- Symlinks need Developer Mode and are generally as much of a mess on Windows as they are on Linux, except even worse as you have to declare up front whether you're pointing at a file or a directory. Or maybe that's an improvement, I dunno.
I also started adding WinPty pseudoterminal support, after refreshing the Eio/pty PR that I started 2.5 years ago! I had to rework fork action handling a bit in Eio as a prerequisite to this work. David Allsopp also pointed me to some potential issues in OCaml's handling of standard descriptors on Windows which is described in his CLOEXEC post.
As an aside, it was also excellent to see OCaml 5.5 get released. I did a quick review of the release notes and very much enjoyed seeing all the new goodies (especially relocatable compiler support).
6 Fun links
- I absolutely love Amol Rajan's Radical podcast, and the latest episode has Shiv Malik fielding questions on his push for a brand-new forest city just outside Cambridge! He really does make a compelling case that we can build our way out of the UK housing crisis, and so affordably, sustainably and equitably.
- Switching to performance deep learning, Sadiq Jaffer sent me this paper on text-to-text regression for predicting the performance of large systems. They train a 60M-parameter encoder-decoder that gets highly accurate correlation predicting resource efficiency on Google's Borg cluster. It does this straight from raw config files and logs with no special feature engineering.
- Plan2Map is a geospatial benchmark that reconstructs machine-readable boundaries from UK planning records. The source documents usually only give us indirect spatial evidence, but now their "GeoPlanAgent" decomposes them into structured data with uncertainty quantification. Might be very neat to apply to our evidence literature database of full text PDFs.
