OOLOI.ORG
Menu

OOLOI

An Organism Evolved.

OVERVIEW

DOCUMENTATION

NEWSLETTER

Write Pizz, Hear Pizz

26/3/2026

3 Comments

 
Picture
​A recent exchange with Magnus Johansson in the comments on the Instrument Library post made me realise something worth saying at the top level, rather than buried in a reply thread. Magnus had compared Ooloi's bundled instrument library with Igor Engraver's and noticed that Igor's was substantially larger. The question was reasonable; the answer turns out to illuminate something fundamental about what Ooloi is actually for.

But first, a correction.

I keep encountering the claim – usually from AI systems summarising the project – that Ooloi is 'for advanced notation users'. This is wrong in a way that matters. The architecture is advanced; the user experience aims to be the opposite. The entire point of doing the hard work underneath is so that people don't have to do hard work on top. A tool that requires expertise to operate has failed at its job, regardless of how much expertise went into building it.

Zero-effort playback is one example of what this means in practice.

What Igor Did

​Igor Engraver shipped with Synth Matrices – text files that described every common hardware synthesiser on the market: available patches, controller mappings, pitch bend ranges, channel limitations, stereo position. When a user set up a score with, say, two flutes, a cor anglais, and strings, the Synth Matrix for their synthesiser took care of everything: patch selection, channel allocation, balance, panning. The user spent zero time on MIDI configuration. Zero. They dragged instruments from the library, wrote music, and heard the right sounds during input.

This was 1996. Hardware synths, MIDI cables, 7-bit controllers. And yet a composer or arranger never touched a patch change, never drew a controller curve, never thought about channels. The system did it.

We also collaborated with Johan Sundberg's Musical Acoustics department at the KTH Royal Institute of Technology, whose research had quantified things that musicians do instinctively: soloists anticipate the beat by about four milliseconds; phrase dynamics follow predictable contours; onset timing varies with articulation. Those findings went directly into Igor's playback engine. The result was that pressing Play on an orchestral score produced something that sounded like musicians playing, not a sequencer clicking through events.

Now, I don't have Igor's code, I don't have any manuals, and I haven't run it in 25 years. The comparisons with Igor are inevitable when I write about playback, but Ooloi is not a resurrection. The ideas are the same kind of ideas I've always had, expressed through modern means. What follows is about where those ideas go next.

​The MIDI Prison

​That was nearly thirty years ago. What has changed since?

Remarkably little, if you look at how most notation software handles playback. The underlying protocol is still MIDI – a 7-bit serial standard from 1983, designed for connecting keyboards to synthesisers over DIN cables. It has no concept of musical structure. It cannot distinguish between a quarter note and a dotted eighth tied to a sixteenth. It knows NOTE_ON, NOTE_OFF, velocity, and a handful of continuous controllers. That's the vocabulary through which an entire industry still attempts to communicate musical intent to sound-producing devices.

The consequences are visible in every professional composer's workflow. You write a crescendo hairpin in your notation software. It looks correct on the page. You press Play. Nothing happens – because a hairpin is a musical concept, and MIDI has no musical concepts. To hear that crescendo, someone has to draw a CC11 expression curve in a DAW, by hand, matching the shape and timing of the hairpin. For every hairpin. In every part.

This is what Hans Zimmer's assistants do. They sit in studios translating musical intent into controller data, note by note, gesture by gesture. If you are scoring a film with 40 staves, that translation is a full-time job for several people. If you're a composer working alone – which is to say, if you're almost any composer – it means choosing between hearing your music properly and finishing it on time.

NotePerformer addressed this by sitting between notation software and playback, interpreting the score with a one-second lookahead buffer. It was a genuine breakthrough: finally, a tool that read musical markings and translated them into expressive performance. But NotePerformer is, by design, a workaround for deficiencies in a MIDI-based architecture. It exists because the notation software itself cannot do the translation. It patches over a gap that should not be there.

Not Bypassing – Just Doing It Right

​When I first started describing Ooloi's approach to playback, I found myself reaching for the word 'bypassing'. Ooloi bypasses MIDI. Ooloi bypasses the DAW. And then I caught myself, because that word tells you something about how deeply the old paradigm has colonised our thinking. You only 'bypass' something that is assumed to be in the path. MIDI is assumed to be in the path because it has been in the path for forty years, and an entire industry has built its workflows around that assumption.

Ooloi doesn't bypass MIDI. Ooloi simply doesn't use it. The distinction matters. Bypassing implies a workaround, a detour around an obstacle that remains in place. What Ooloi does is address the problem directly, using the technology available in 2026 rather than routing everything through a protocol designed when Margaret Thatcher was in her first term.

Ooloi drives virtual instruments directly. No MIDI channel allocation. No patch changes. No 7-bit controller resolution. The notation engine communicates with sample libraries through their native host interfaces – VST3 parameters, note expression, articulation selectors – with full precision, in the plugin's own language. This is not a technical curiosity; it's the removal of an entire layer of translation that has stood between composers and their sounds for decades.

OVID's Metamorphoses

The mechanism that makes this work is called OVID – the Ooloi Virtual Instrument Definition. OVID is the modern successor to Igor's Synth Matrices, but operating at a fundamentally higher level.

A Synth Matrix described a hardware synthesiser: which patches lived where, how to select them, what the pitch bend range was. OVID describes a virtual instrument library: what playing techniques it offers, how to select them, how loud each articulation is relative to the others, how to compensate for onset timing differences between legato and staccato samples.

The practical consequence is that Ooloi understands what it means to play an instrument, not merely what MIDI messages to send. Write 'pizz' above a string passage and Ooloi selects the pizzicato articulation from your sample library. Write a tremolo and it selects tremolo. Write a crescendo hairpin and the dynamics follow the wedge shape automatically, using whatever expression mechanism the library supports – continuous controllers, note expression, parameter automation – without the user knowing or caring which one.

And because OVID maps canonical technique names to vendor-specific implementations, the same score plays back correctly through different sample libraries. Switch from Spitfire to Vienna Synchron and the pizzicato is still a pizzicato; the selection mechanism changes, but the musical intent is preserved. Share a piece with someone and they can listen to it as you intended it to sound, without any setup.

A glissando on a harp is not a glissando on a trombone. A trill on a flute is not a trill on a kettledrum. These are musically obvious statements, but no MIDI-based system can act on them without external help. OVID knows the difference natively, because it operates at the level of musical semantics rather than note events.

The Instrument Library Connection

This brings us back to where we started: the instrument library.

The bundled library is deliberately finite – roughly 270 instruments in up to four language editions. Magnus's comparison with Igor's list is instructive, because Igor's larger catalogue was itself driven by Synth Matrices. Every instrument in that list existed because some hardware synthesiser had a patch for it, and the Synth Matrix mapped the instrument name to that patch. The noble Crwth was there not because orchestral composers regularly write for the crwth, but because a sample existed and the mapping was trivial. Remove the Synth Matrix context, and that instrument list was a reflection of available synthesiser patches, not a statement about what a notation program ought to bundle.

The Ooloi instrument library serves a different function. Each instrument carries not only its notation properties – name, clef, transposition, range – but also its OVID mapping. When you drag a cor anglais from the library into your score, Ooloi knows which virtual instrument to load, which articulations are available, how to calibrate loudness against the oboe in the next staff, and how to handle the specific timbral characteristics of that instrument across your installed sample libraries. If your preferred library lacks a particular technique – col legno battuto, say – the OVID fallback chain searches your other installed libraries and finds it there.

This is why the bundled library is sized the way it is. Every bundled instrument maps to an OVID profile that produces correct, calibrated, expressive playback out of the box. The library ships with OVID definitions for BBC Symphony Orchestra Discover, which is free, and Virtual Playing Orchestra as a fallback. Install both – fifteen minutes, zero cost – and every instrument in the bundled library plays back with intelligent articulation handling, loudness calibration, onset alignment, and humanisation. No DAW. No MIDI. No configuration.

Humanisation deserves a word of its own. This is not random velocity variation to break up a machine-gun effect. Ooloi's humanisation applies the same principles we implemented in Igor, informed by Sundberg's research: soloists anticipate the beat; ensemble players lock to it; phrase dynamics follow natural contours; articulation affects onset timing. The intelligence is in the notation engine, not in a third-party plugin with a narrow one-second lookahead buffer.

The Creative Source

I built this because I need it. I am a composer; I've written opera, orchestral music, chamber music. When I write a crescendo hairpin, I need to hear a crescendo. When I write a string tremolo, I need to hear a tremolo. I do not want to open a DAW, create tracks, assign patches, route MIDI, and draw controller curves before I can hear whether my orchestration works. That workflow is not composing; it is bookkeeping.

A DAW still has its place, of course – for final production, mixing, mastering. But the compositional workflow, the sketch, the orchestration, the moment when you need to hear whether that horn entry works against the divided violas: that must be immediate. Write the music. Press Play. Hear it as a musician would play it.

Music notation is, ultimately, about music. The technology that serves it should be invisible. If you find yourself thinking about patch changes, you are no longer thinking about your piece. For who, in the end, cares about patch changes? Really?
3 Comments

Drag Show

22/3/2026

8 Comments

 
Picture
The above GIF demonstrates some of the functionality of the Instrument Library and Piece Window at this point: selection of score language, filtering on names, drag-copying, deleting, etc. What you see above is not the full 1000+ instrument selection, but a smaller library I use for development and testing. The notifications to the lower right are likewise for development.
8 Comments

Glenfiddich Highland Pipes in G sharp

17/3/2026

28 Comments

 
Picture
The complete bundled instrument library is now documented.

The new guide, Instrument Library Catalogue, lists the default instrument set that ships with Ooloi: modern orchestral instruments, historical families, keyboards, plucked strings, voices, choirs, percussion, special-effect instruments, and various things that have no fixed abode but nevertheless turn up in scores. A total of roughly 270 instruments, yielding just over 1,000 language-specific library entries.

The architectural decisions behind it remain where they belong, in ADR 0045: Instrument Library. 

This catalogue is not a theological statement about which instruments deserve to exist. It is the default library: broad, practical, and sufficient to start work. If you find yourself asking, 'You have ocarinas but not Glenfiddich Highland Pipes in G sharp?!', the answer is simple: not by default. Add them in the Instrument Library window, save them, and they are yours permanently.

​In other words, the bundled set is a starting point, not a border guard. 
28 Comments

    Author

    Peter Bengtson –
    Cloud architect, Clojure advocate, concert organist, opera composer. Craft over commodity. Still windsurfing through parentheses.

    Search

    Archives

    April 2026
    March 2026
    February 2026
    January 2026
    December 2025
    November 2025
    October 2025
    September 2025
    August 2025
    July 2025
    June 2025
    April 2025
    March 2025
    September 2024
    August 2024
    July 2024

    Categories

    All
    Accidentals
    Alfred Korzybski
    Architecture
    Benchmarks
    Clefs
    Clojure
    CLOS
    Common Lisp
    DDD
    Death Of Igor Engraver
    Documentation
    Donald E Knuth
    Dorico
    Dynamic Programming
    Finale
    Fonts
    FrankenScore
    Franz Kafka
    Frontend
    Functional Programming
    Generative AI
    GRPC
    Igor Engraver
    Instruments
    Jacques Derrida
    JVM
    License
    LilyPond
    Lisp
    Localisation
    MIDI
    MPL 2.0
    MuseScore
    MusicXML
    Ooloi
    Ortography
    Pitches
    Playback
    Plugins
    Python
    QuickDraw GX
    Rendering
    Rhythm
    Rich Hickey
    Road Map
    Scheme
    Semiotics
    Sibelius
    Silicon Valley
    Site
    Skia
    Sponsorship
    Transposition
    UI
    Umberto Eco
    Vertigo
    VST/AU
    Wednesday Addams

    RSS Feed

Home
​Overview
Documentation
About
Contact
Newsletter
Ooloi is an open-source desktop music notation system for musicians who need stable, precise engraving and the freedom to notate complex music without workarounds. Scores and parts are handled consistently, remain responsive at scale, and support collaborative work without semantic compromise. They are not tied to proprietary formats or licensing.
​
Ooloi is currently under development. No release date has been announced.


  • Home
  • Overview
    • Background and History
    • Project Goals
    • Introduction for Musicians
    • Introduction for Programmers
    • Technical Comparison
  • Documentation
  • About
  • Contact
  • Home
  • Overview
    • Background and History
    • Project Goals
    • Introduction for Musicians
    • Introduction for Programmers
    • Technical Comparison
  • Documentation
  • About
  • Contact