Ooloi: Symbionts, Not Conquerors

Invasion of the Body Snatchers (1956) – are you SURE your wife isn't a communist?

Twenty-five years ago, Igor Engraver emerged from my odd combination of musical background and programming obsessions. I couldn't have predicted that its spiritual successor would find its perfect metaphor in Octavia Butler's extraordinary aliens. Yet here we are: Ooloi – the music notation system – named for Butler's third-gendered beings who mediate genetic exchange between species, enabling new forms of life through symbiosis rather than conquest.

Butler's Ooloi operate without competitive hierarchy. They heal cellular damage and create possibilities that neither parent organism could achieve alone. This captures something essential about what Ooloi the software represents: not competitor, but enabler.

The Economics of Innovation

​Igor's demise taught me harsh lessons about market timing. When you create genuinely superior tools because existing software actively gets in your way, you discover that technical excellence alone can't guarantee survival.

Igor actually started as freeware – that was my original vision. The VCs wanted features, revenue streams, market capture. I wanted musicians to have tools that actually served their creativity. The collision between these fundamentally incompatible visions, plus the economic chaos after 9/11, killed what could have been transformative.

That experience shaped every decision in Ooloi. This time: transformation through collaboration rather than zero-sum market battles.

Architecture as Philosophy

Traditional music notation software struggles with fundamental problems: mutable object graphs that resist collaboration, pointer-based relationships that become nightmarishly complex, threading models that can't use modern processors properly.

These aren't performance issues – they're architectural dead ends. Finale's discontinuation after 35+ years proves the point: when technical debt becomes so extensive that maintaining code needs more effort than rebuilding, the architecture has failed.

Ooloi's functional programming eliminates entire classes of bugs whilst enabling capabilities that remain impossible in traditional systems. Pure tree structures with integer references eliminate pointer complexities. Software Transactional Memory provides automatic conflict resolution. Vector Path Descriptors create addressing that survives layout changes.

But the key insight: by separating frontend and backend through gRPC, Ooloi becomes platform rather than just application. New notation software could be built on it from the start – much like computer game developers can choose Unreal Engine 5 rather than build and maintain their own game engines.

The architecture also opens more sinister possibilities. Technically, established software could adopt Ooloi's backend whilst keeping their existing frontends – a sort of "Invasion of the Body Snatchers" scenario for software architecture, though that would require significant integration work.

Non-Competition in Practice

The MPL 2.0 licensing reflects this philosophical approach. The core backend becomes commoditised infrastructure; commercial value migrates to sophisticated interfaces, proprietary plugins, premium workflows. What traditional systems charge for – collaboration, large ensemble support, quality rendering – becomes architectural givens.

This isn't theoretical. Martin Keary (Tantacrul), who heads MuseScore development, had been interested in Igor Engraver as a young composer. When we discussed our open source projects, the conversation was refreshingly direct: 'Well, feel free to help yourself to whatever's useful when it goes open source​' – 'Likewise!' Both projects share the belief that notation software shouldn't cost students hundreds of pounds.

This is precisely what I want – for the code to be used, extended, transformed. The platform approach only works if others build on it. That's not threat; it's the point.

Personal Vindication

​The irony isn't lost on me that companies who once viewed architectural advances as existential threats might ultimately benefit from them. I still recall Sibelius management phoning after Igor's demise to enquire about my plans – ensuring no resurrection attempts, obviously.

Should those companies adopt approaches they once feared, the satisfaction would be collaborative rather than competitive. Success through enabling others, not defeating them.

Does It Actually Work?

​Of course, this depends on Ooloi actually working. Functional programming should provide significant performance benefits, but what happens with complex layout calculations across a hypercomplex 100-staff score by Brian Ferneyhough (whom I had as guest teacher at the Royal College of Music in Stockholm back in the day) whilst maintaining real-time collaboration?

The arrogance in predicting that these approaches will outperform decades of commercial development is considerable. My instincts could be spectacularly wrong – though they've been reliable enough to spot architectural dead ends before they become obvious to everyone else.

That's the architect's bargain: trust your reasoning, build on principles, prepare to be surprised.

Ferneyhough: a simple little tune

Next-Gen, If the Term Means Anything

"Next-generation" gets thrown around as a PR term so casually it's meaningless. If Ooloi genuinely represents next-generation architecture, that should be inherent in the platform design rather than claimed through marketing. The question isn't whether Ooloi calls itself next-gen, but whether others build on it in ways that would have been impossible previously.

Perhaps this time, it might be composed collaboratively.

Ooloi isn't here to "disrupt" anything. I despise that cheap neoliberal selfishness. It aims to transform, to evolve, to open possibilities. But there's no will to conquer — it's simply not in its DNA.