For the third year running, The Perl and Raku Foundation is thrilled to announcea gift of USD 25,000 from DuckDuckGo, part of their2026 charitable donations.Recurring donations allow the foundation much more flexibility when planning a budget 12months in advance, especially when it comes to ensuring that grants for Perl 5core development will be funded in the year ahead.
DuckDuckGo’s support is greatly appreciated and goes directly to sustain thekey people who maintain Perl – the developers who fix vulnerabilities,improve performance, and keep the language stable for millions of systemsworldwide. Donations like this are what keep Perl maintained and progressing.– Stuart Mackintosh, President, The Perl and Raku Foundation
Perl received 2,382 commits in 2025 and 1,925 so far in 2026. These includedfixes for eight security vulnerabilities (CVEs), new language features, andperformance improvements. Just as critical is the largely unseen work of codereview, issue triage, and security response. Sponsored maintainers wrote nearlya quarter of these commits and carried much of that background work – work thatcontributions like this help make possible.Gifts from donors further ensure that the foundation can continue itsday-to-day work, including:
funding and administering grants for work on the Perl core
Since discovering Perl real-time MIDI and writing about creating async drums with it, I’ve dug deeper into what’s possible. I have a few music and MIDI modules on CPAN and like to put them to use in real time, now that I have been enlightened by zen master John Barrett. Ha :DThis will be a mostly commented-code illustration of real-time arpeggiation. It is maybe “just a hobby.” But the principles of asynchronous programming, periodic execution of a set of things, are generically applicable to other types of problems.There is no perplexing music theory here: just some terms to know. A note is a little vector of a pitch (high or low) and a duration (long or short). A scale is a collection of pitches, starting at the tonic. An octave is the musical interval between one note and another, where each has the same letter name but twice (or half) its frequency (in Hertz). A clock is a MIDI message sent to a device to keep timing. MIDI stands for “musical instrument digital interface” and is the beating heart of a lot of digital music. An arpeggio is usually a chord of the chosen scale, where the notes are played individually in rising or descending order. A chord is a collection of three or more notes. An arpeggio is played over a given spread or range of beat durations. A beat is an atom of the rhythm. The rhythm is the collection of note durations of a phrase. A measure of musical time is a group of beats most commonly four. Finally, the term velocity is equivalent to the volume or loudness of a note. Whew!Anyway, on with the show. (And audio examples are at the bottom.)
Broad strokes
What this is:A generative arpeggiator that runs forever, choosing random scale notes and random arpeggios. This plays them on a MIDI synth, all driven by a MIDI clock.The core ideas:
A universe of notes defined by a tonic pitch, a scale name, and a set of octaves
An asynchronous clock engine using a periodic timer to drive events and MIDI messaging
Phrase generation with flexible arpeggio parameters and velocity randomization
Graceful shutdown with all-notes-off/panic being the important part
Code overview:
Dependency imports
Optional parameters that guide the processing
Internal parameters defining program operation
Cleanup on program halt
Loop and periodic timer
Handy subroutines
Basically, this code is all machinery to play things in real time. The actual arpeggiation is pretty simple and happens at the beginning of the trigger_notes() routine, given the object.Let’s look at each of these in closer detail.
Dependency imports
use v5.36; # use a modern Perluse IO::Async::Loop (); # asyncuse IO::Async::Timer::Periodic (); # asyncuse List::Util qw(max sum0); # duration scalinguse MIDI::RtMidi::Util qw(out_port stop_all_notes); # rt-midiuse Music::MelodicDevice::Arpeggiation (); # arpeggiosuse Music::Scales qw(get_scale_MIDI); # pitches
Optional parameters
my %opt = ( port =>'synth', # required MIDI device (e.g. microKORG or fluidsynth) bpm =>80, # beats-per-minute arp_type =>'any', # 'any' or any known to the arp module note_num =>'5,7', # number of notes to arp repeats =>1, # arp repeats before the next one begins spread =>4, # beats an arp should stretch across octave =>'3,4,5', # octaves (0 .. 9) tonic =>'C', # scale key base note scale =>'minor', # scale name as known to Music::Scales program =>0, # synth program channel =>0, # the MIDI channel);
Internal parameters
# one arpeggiator instance is reusedmy= Music::MelodicDevice::Arpeggiation->new( repeats => {repeats}, verbose =>1,);# used to rescale durationsmy= Music::MelodicDevice::Arpeggiation::TICKS();# split thingsmy @octave = split /,/, {octave};my @note_nums = split /,/, {note_num};my @arp_types = {arp_type} eq'any' ? keys ->arp_type->%* : split /,/, {arp_type}; # see the Music::MelodicDevice::Arpeggiation docs# get full range of pitches by octavemy @pitches = map { get_scale_MIDI({tonic}, $_, {scale}) } @octave;die "No pitches for tonic={tonic} scale={scale}\n"unless @pitches;say "Arp types: {arp_type}";say "Arp nums: {note_num}";say "Pitches: @pitches";# we are in 4/4 time...my=4; # useful factor :)my=6* ; # PPQNmy=60/ {bpm} / ; # time / bpm / ppqn# when spread is falsy, fall back to one bar's worth of beatsmy= {spread} || ;my @active; # { note => , off_tick => }my @pending; # { note => , on_tick => }my=0; # clock ticksmy=0; # beats!# open the MIDI device for outputmy= out_port({port});->program_change({channel}, {program});say "Opened {port}";
Cleanup
# Ctrl-C clean shutdown{INT} =sub { say "\nStop"; stop_all_notes(); # make sure all notes are off exit;};
Loop and timer
# loop object to own and drive all timers/eventsmy= IO::Async::Loop->new;# drive the whole sequencer clock out, note off, note on, retriggermy= IO::Async::Timer::Periodic->new( interval => , reschedule =>'hard', # anchor to a fixed schedule, don't let tempo drift on_tick =>sub {->clock; # emit a MIDI clock tick++; # advance the master tick counter# release any notes whose time is upformy $i (reverse 0.. $#active) {# iterate in reverse so splice() below doesn't invalidate remaining indicesif ( >= [$i]{off_tick}) {->note_off({channel}, [$i]{note}, 0); splice @active, $i, 1; # remove from the "currently sounding" list } }# align to fire exactly on beat boundariesif (( -1) % $clocks_per_beat ==0) {if ( % $phrase_beats ==0) { # retrigger every trigger_notes(); # start a new arp phrase! }++; # only increment on beat boundaries }# collect every pending note whose start time has arrivedmy @ready = grep { >= $_->{on_tick} } @pending;# keep the notes still waiting for a future tick @pending = grep { < $_->{on_tick} } @pending;formy $p (@ready) {->note_on({channel}, $p->{note}, velocity(-10, 10, 110));# remember the note, so the release loop above can turn it off at the right tick push @active, { note => $p->{note}, off_tick => $p->{off_tick} }; } },);->start;->add();->run;
Handy subroutines
subtrigger_notes {# pick a random note count, then that many random pitches, sorted low-to-high for the arpeggiatormy @notes = sort { $a <=> $b } map { [int rand @pitches] } 1.. [int rand @note_nums]; # XXX clunky# get an arpeggiated note list given a random arp_typemy=->arp(\@notes, 1, [int rand @arp_types]);# convert from the arp's 96-ticks-per-quarter-note scale to our clock ticksmy @raw_ticks = map {my () = $_->[0] =~ /^d(\d+)$/; # duration encoded as a string like "d96"# rescale from the module's tick resolution to our own clock's ticks-per-beat max(1, int( */ )); } @;my=1; # default multiplier: 1 = no rescalingif ({spread}) {# total unscaled duration of the arpmy= sum0(@raw_ticks) ||1;# convert the desired spread (in beats) into tick unitsmy= {spread} * ;# factor that stretches or squeezes the arp's total length to exactly fill the available ticks=/ ; }# anchor the first note of this phrase to "right now" of the master clockmy= ;formy $i (0.. $#) {my (undef, ) = @{ ->[$i] }; # a note is a duration and a pitch# note's scaled length, floored at 1 tickmy= max(1, int([$i] * ));# schedule the note to be turned on/off push @pending, { note => , on_tick => , off_tick =>+ , };# advance the cursor so the next note in the arp starts right where this one ends+= ; }}subvelocity (00, , ) {# generate a randomized velocity within [min+offset, max+offset]my=+ int(rand( - 00 +1)) + 00;return ;}
A superior implementation would use the Getopt::Long module to parse command-line arguments. Hint, hint. ;)
Audio examples
This is the General MIDI piano played with fluidsynth:Not terribly exciting, yet.The following were recorded with my microKORG synthesizer. But any MIDI-capable synth will do!This one sounds like an arcade. It repeats the arp twice:With an old-school sound and an already arpeggiated synth patch:Here is another:OK. How about an ethereal pad arping in slow motion?~And here is an example of the verbose console output that is produced:
The port that is opened is my MIDI interface to the microKORG, which is partly named midimate. It is worth pointing out that the out_port() function uses case-insensitive substrings/regexes to match MIDI device names.
Conclusions
You too can make MIDI music in real-time! And arpeggios are a highly useful technique for “filling the silence.”Timing events with async code takes quite a bit of logic. And sleeping is not an option.These techniques have wider usefulness. Knowledge of event systems is essential for programming graphical and interactive applications, high-concurrency network services, simulations, , and more! :-)
The Perl and Raku Foundation (TPRF) is grateful to announce a gift of $12,000from NVIDIA in support of Perl and CPAN. Contributions like this one let uskeep maintaining the Perl 5 core and support our mission of keeping criticalinfrastructure alive.When you think of NVIDIA, you may think of GPUs and LLMs, so let’s highlight afew related projects with ties to the Perl and Raku communities.
Superpowers
The first project that springs to mind is Jesse Vincent’s Superpowers.
Superpowers is a complete software development methodology for your coding agents, built on top of a set of composable skills and some initial instructions that make sure your agent uses them.
While this is not written in Perl or Raku, Jesse was the Perl pumpking for versions 5.12 and 5.14 of the language. As his Wikipedia entry notes:
He changed the release cycle for Perl 5 from an irregular release done at theleisure of the project manager to a regular timeboxed release withdevelopment releases monthly and stable releases annually.
So the annual stable release cycle we now take for granted is largely thanks toJesse’s work.
PAAD (rhymes with “pad”) is a set of skills for AI coding assistants. It reviews what the AI is about to work on the spec, the plan, the architecture, the code while you can still change it. That’s Pushback, Alignment, Architecture, plus the Discipline to actually run them.
skilletor is a Claude Code and Codex plugin plus a standalone CLI. It installs skills, agents and rules from configured sources and keeps them up to date: it reconciles at session start, re-checks (throttled) during the session, pulls anything new, and tells the model what changed. Want shared skills? This is most likely the tool.
Getty has many Perl projects on the go, one of the more ambitious beingDBIO, a native relational mapper built on DBIand a modern successor to DBIx::Class.He also maintains Langertha:
Langertha provides a unified Perl interface for interacting with various Large Language Model (LLM) APIs. It abstracts away provider-specific differences, giving you a consistent API whether you’re using OpenAI, Anthropic Claude, Ollama, Groq, Mistral, or other providers.
Once again, we’d like to thank NVIDIA for supporting Perl and CPAN. If yourorganization relies on these ecosystems, you can supportTPRF or budget engineering timefor the shared infrastructure you already depend on.
Since the end of the Perl Toolchain Summit in Vienna, at the end ofApril, the organizers have been busy wrapping up 2026, and preparing for2027. One of our main goals for this year is to be ready long before2027 has even started.And so today we’re happy to announce that the 17th Perl ToolchainSummit will be held in Lyon, France, from Thursday April 29 till SundayMay 2, 2027.This post is brought to you by The Perl and Raku Foundation,a recurring Diamond sponsor of the Perl Toolchain Summit.Started in 2008 as the Perl QA Hackathon in Oslo, the Perl ToolchainSummit is an annual event that brings together the key developersworking on the Perl toolchain. Each year (except for 2020-2022), theevent moves from country to country all over Europe, organized by localteams of volunteers. The surplus money from previous summits helps fundthe next one.Since 2023, the organizing team is formally split between a “global”team and a “local” team (although this setup has been informallyused before).Our global team is made up of veteran PTS organizers, who deal withinvitations, finding sponsors, paying bills and communications. They areLaurent Boivin (ELBEHO), PhilippeBruhat (BOOK), Thibault Duponchelle(CONTRA), and Breno de Oliveira(GARU), supported by Les Mongueursde Perl’s bank account.This year, the local team is just Philippe, who lives near Lyon.This will be the fourth Perl Toolchain Summit held in the city,meaning we already have all the local stuff very well in hand.We’ll return to our usual venue there, a hotel in front of the trainstation and across the street from the airport shuttle, which has hostedthe Summit in 2017 and 2023 (and one Sunday in 2014).The developers who maintain CPAN and associated tools and services areall volunteers, scattered across the globe. This event is the one timein the year when they can get together.The summit provides dedicated time to work on the critical systemsand tools, with all the right people in the same room. The attendeeshammer out solutions to thorny problems and discuss new ideas to keepthe toolchain moving forward. We’re still working on the attendees listat the moment, and we expect 30 to 35 people to join us in Lyon next year.Given the important nature of the attendees’ work and their volunteerstatus, we try to pay for most expenses (travel, lodging, food, etc.)through sponsorship. Another goal for this year is to break even (we’vebeen running the summit at a loss for the past few years, using up ourtreasure chest). If you’re interested in helping sponsor the summit,please get in touch with the global team atpts2027@perltoolchainsummit.org.The Perl and Raku Foundation has beensponsoring the Perl Toolchain Summit for several years now, either viadirect financial contributions, or by funding travel for some of ourattendees. We are very grateful for their continued support.
The Perl and Raku Foundation is delighted to once again support thePerl Toolchain Summit as a Diamond Sponsor. The Summit brings togetherthe dedicated people who build and maintain the tools and infrastructurethe Perl community relies on every day. TPRF is proud to help give thesecontributors the time and space to work together, solve problems, andstrengthen the ecosystem for everyone. The Foundation looks forward toanother productive and inspiring Perl Toolchain Summit in 2027.
