Ooloi Development and Collaboration Strategy


​Project Overview

Ooloi is a modern, open-source music notation software designed to handle complex musical scores with ease. Built using Clojure, JavaFX, Skija, and gRPC, it provides a high-performance platform for music notation with a plugin architecture that supports extension in any JVM language.

Three-Phase Development Approach

Ooloi's development follows a strategic three-phase approach designed to maintain architectural integrity while maximizing collaboration opportunities:
  1. The solo closed-source phase, where Peter Bengtson implements the Clojure core engine,
  2. The open-source core contribution phase using Clojure,
  3. The open-source plugin contribution phase where any JVM language can be used.
Phases 2 and 3 take place simultaneously, addressing different contributor audiences.

Strategic Benefits
  1. Architectural Integrity: Core development remains controlled and consistent with the founding vision
  2. Dual Contribution Paths: Provides appropriate engagement options for both Clojure specialists and domain experts in other languages
  3. Broad Accessibility: The abstracted API allows contributors to work in familiar languages without dealing with low-level concerns
  4. Commercial Integration: Companies can develop plugins using their preferred languages and methodologies
  5. Natural Progression: Plugin developers can gain system understanding that may eventually lead to core contributions
  6. Specialization Support: Contributors can focus on specific areas of expertise (technical or musical)


Phase 1: Solo Development to Functional Milestone

Current Status
  • Backend architecture completed
  • Moving toward frontend development and integration
  • Solo development until note entry and printing are implemented
  • Will transition to open source only after reaching this critical milestone

Completed Backend Elements
  • Robust platform with ACID-compliant transactions (100,000+ transactions/second)
  • Polymorphic Public API with composable STM transactions
  • Vector Path Descriptor (VPD) system for efficient data access
  • Pure tree structure eliminating circular references
  • Elegant solution for non-pure elements (slurs, ties) using Methodical's :around handling
  • File persistence using Nippy (serialization, async I/O, streaming)
  • Comprehensive testing (15,000+ generative tests)
  • 98.5%+ test coverage

Currently In Progress
  1. Component Implementation
  • Making Piece Manager the first Integrant component
  • Designing component boundaries for lifecycle management
  • Implementing configuration handling
  2. gRPC Communication Layer
  • Setting up gRPC server and defining protocols
  • Creating the second component (gRPC server)
  • Implementing event system with core.async
  • Designing bi-directional streaming for notifications
  3. Frontend Foundation Development
  • Setting up JavaFX project structure
  • Implementing gRPC client
  • Creating UI with basic note entry
  • Establishing data synchronization patterns
  • Implementing printing capabilities

Documentation and Infrastructure Preparation
  • Creating API documentation emphasizing abstraction benefits
  • Preparing multilingual examples in various JVM languages
  • Developing architectural documentation
  • Creating onboarding materials for future contributors
  • Finalizing repository structure for public visibility
  • Establishing contribution workflows and guidelines


Phase 2: Core Clojure Contribution Path

Target Contributors
  • Experienced Clojure developers
  • Functional programming enthusiasts
  • Contributors with interest in system architecture
  • Music notation experts willing to learn Clojure

How Core Contributors Work
  • Direct collaboration on the core codebase
  • Access to entire system architecture
  • Work with STM, VPDs, and other advanced Clojure concepts
  • Participate in architectural decisions and core optimizations
  • Contribute to both backend and frontend components
  • Implement complex musical notation features

Contribution Areas
  • Core engine optimization and enhancement
  • Backend architectural improvements
  • Frontend rendering and UI components
  • Concurrency and transaction management
  • Advanced musical notation features
  • Persistence and file format development

Support Infrastructure
  • Clojure-specific development guides
  • Architectural deep dives
  • Core codebase walkthroughs
  • Rigorous code review process
  • Mentorship from project founder

Quality Control Mechanisms
  • 98.5%+ test coverage requirement
  • Adherence to functional programming principles
  • Consistency with architectural vision
  • Performance benchmarking
  • Extended testing strategies for cross-component scenarios
  • Simulation tests for concurrent editing


Phase 3: JVM Plugin Contribution Path

Key Benefit: Pure Abstraction
  • Contributors work entirely through high-level API
  • No need to understand/manage transactions or concurrency
  • Focus exclusively on musical domain problems
  • Use familiar development patterns and tools in any JVM language

How Plugin Contributors Work
  • Develop extensions using any JVM language
  • Interact only with the high-level API
  • No need to understand core implementation details
  • Focus solely on specialized musical domain problems
  • Can create commercial plugins with proprietary code
  • Work independently from core development processes
  • Deploy to plugin marketplace when available

Target Contributors
  • Developers in any JVM language (Java, Kotlin, Scala, etc.)
  • Music domain experts with programming experience
  • Commercial entities
  • Academic researchers and specialists

Contribution Areas
  • Specialized notation systems (tablature, jazz, early music)
  • Import/export functionality (MusicXML, MIDI, PDF)
  • Analysis tools (harmony, form, performance)
  • Educational extensions
  • Integration with external systems
  • Commercial vertical market solutions

Support Infrastructure
  • Language-specific starter templates for all major JVM languages
  • Multilingual API documentation with idiomatic examples
  • Plugin development guides for each language
  • Testing frameworks for plugin validation
  • Commercial integration support (Cryptolens)
  • Plugin marketplace and discovery tools

Quality Control
  • Plugin validation test suite
  • Performance benchmarking guidelines
  • User experience standards
  • Version compatibility verification


Implementation Timeline

Pre-Release (Current)
  • Complete note entry and printing - critical milestone for open-source release
  • Finalize plugin API design and documentation
  • Prepare multilingual examples
  • Establish contribution guidelines

Initial Release
  • Open-source repository after reaching note entry and printing milestone
  • Release with example plugins in multiple JVM languages
  • Launch developer documentation
  • Begin recruiting contributors
​
Future Advanced Features
  • Collaborative editing with conflict resolution
  • Dynamic classloading for plugins
  • High-quality printing and page layout
  • Memory optimization for very large scores
  • Measure reformatting and reflow
  • Advanced musical notation algorithms