Introduction

I’m a software developer. Which basically means two things:

1. I’m lazy.
2. I take that very seriously.

If something can be automated, it will be. If it can’t… well… that’s probably because I haven’t added enough unnecessary complexity yet.

A current example: normal people pick up a guitar to express emotion. At some point, I picked one up and thought, “This could really use a control plane.”

So instead of just playing music, I built… whatever this is. It looks like an unstable molecule. Every song is essentially an unpredictable runtime environment that, somehow, hasn’t collapsed yet.

This is the Loopinarium (or L∞π∩∆rium, as I prefer to write it). In a strange way, it feels like an extension of myself.

Cerebral Duality

“You need to exercise logic and emotion together, otherwise your brain is going to collapse, Marcelo,” my psychiatrist told me.

She also happens to be a neurologist, which made her uniquely qualified to understand what the hell was going on with me.

It was a dark period. I had panic attacks fairly often and, apparently, episodes of epilepsy as well. The tricky thing about evaluating conditions like that is actually being inside a machine while the episode is happening. I underwent cerebral perfusion scintigraphy, transcranial Doppler ultrasonography, and even a Rorschach test.

Incidentally, one line from that report caught my attention:

High intelligence emotionally blocked.

Was that related to what my psychiatrist had said?

I’ll probably never know for sure. I never followed through with the examinations, despite some of them pointing toward uncomfortable investigation paths. I’ve never been particularly fond of labels, and for years I forgot some of the diagnoses I received as a child. I only remembered them later during the romanticized fever dream fueled by certain brainless corners of the internet, where people seem to study for the neurodivergence exam in hopes of earning the certificate that apparently grants them permission to keep being idiots without taking responsibility for their words or actions. They can now conveniently hide behind the people who genuinely need help.

The world has become far too binary.

Everything turns into conflict when there are only two sides. The spectrum has been compressed into Side A and Side B, like an old vinyl record. And just as there are people blindly in love with musical nostalgia, refusing to accept that digital audio is objectively superior to vinyl (look at the irony of bilateral thinking), there are people equally obsessed with labels and with belonging to groups that probably shouldn’t exist in the form they exist today.

Let me explain and, while I’m at it, correct my own flawed musical binary thinking.

Digital audio is not homogeneous. There are countless formats with different sampling rates. At some point, the sampling rate becomes so effective to human hearing that the digital world becomes indistinguishable from the analog one. Thank you, Fourier!

Just as there is a spectrum of sampling rates, and a point on that spectrum where digital and analog become effectively equivalent, there is a spectrum of neurodivergence. And there is a point on that spectrum where its members can be considered fully functional adults. (To be fair, not all neurotypical people qualify as fully functional adults either, but I digress.)

I sit exactly at that point on the spectrum. I am a functional adult.

The bilateral nature of the way I function does create a certain amount of internal conflict. Learning to tame that conflict is part of my essence—part of what it means to exist as me.

For as long as I can remember, I’ve been fascinated by science, especially mathematics and physics. Then, sometime around the early 2000s, a new passion entered my life: music.

Not in the sense of listening to it. In the sense of using it to express myself.

Emotion

Back then, I learned to compose in the most simplistic way imaginable. My focus was always instrumental music. I dreamed of becoming a film score composer because it seemed like the perfect way to make a living from music without anyone recognizing me on the street. The foolish assumption that every successful musician would be famous led me somewhere unexpected: composing music so I could fall asleep.

And there I was, with a CD playing my humble little lullabies, hoping I wouldn’t annoy my brothers. Those tracks became my sleeping pills for years. I’d play guitar during the day and listen to my own little tunes at night.

I learned to compose using a piece of software called Guitar Pro, which I also used to learn a few classical guitar pieces. I was in high school at the time, and my friend Gustavo not only taught me the basics but encouraged me to keep playing. I still remember him teaching me the intro to Original Prankster on our very first day.

My mother, who had learned guitar in her younger years, showed me a few finger exercises to practice. She used to play a beautiful piece called Jeux Interdits, and when I eventually found a Guitar Pro version of it, I made it my mission to learn it too.

My father told me he’d buy me a guitar once I learned to play well. I found some classical guitar studies by the Spanish guitarist Fernando Sor and dove right in. Later, while learning Asturias by another Spanish composer, Isaac Albéniz, I showed my father what I could do.

His response was:

“That’s not exactly what I meant by playing well. I was thinking more along the lines of a little samba tune.”

I got the guitar anyway and continued learning Spanish repertoire the only way I knew how: without a human teacher.

At some point, I started tinkering with the software a bit more and ventured into editing the files myself. Since I didn’t really know the best fingerings for certain passages, I adapted everything to fit my limitations. In the process, I learned how to place notes on those six lines representing the guitar strings, which felt far less intimidating than the five mysterious lines sitting above them.

The timeline gets a little blurry around this part of my teenage years, but I remember stumbling across some files on the internet with a strange extension: .mid.

I was looking for video game music, especially from the Sega Genesis and Super Nintendo era, and eventually found songs in this mysterious format. A bit of research later, I discovered software capable of opening them.

My mind exploded!

The sounds themselves weren’t particularly impressive, but hearing the exact music from the games I loved was incredible. Everything separated by instrument. The software even displayed the notes on a piano keyboard.

That’s when I started borrowing musical ideas for my bedtime compositions. I discovered that Guitar Pro could import .mid files, so I began adapting songs for guitar while continuing to compose my own.

Eventually, I hit a wall. I simply couldn’t write music anymore. Probably a consequence of never having received formal training.

The spark returned decades later when I stumbled upon a fascinating form of musical expression: looping.

Since I had virtually no musical education, my compositions consisted of little more than a handful of chords and painfully simple solos confined to a few scales. Repetitive. Predictable. Boring.

But I liked them because they were mine. Much like a fart, my music was appreciated almost exclusively by its creator.

So where does looping fit into all of this?

Simple: with only a few chords and several layers, perhaps I could create something more interesting. Something that could serve as a foundation for a form of expression I had grown to love: improvisation.

I still remember the day I was walking around with a guitar slung over my shoulder when I spotted an elderly gentleman walking his little dog. Instead of offering me candy, he offered guitar lessons.

What I didn’t know was that he was the magnificent guitarist João Domingues.

Our shared love for Bossa Nova and Brazilian music quickly transformed us from teacher and student into musical partners within a matter of months.

As I learned instrumental arrangements from Almir Chediak’s songbooks, I also learned how to move through chord progressions more freely. Improvisation still doesn’t come naturally to me, and perhaps it never will, but that’s where I took my first steps, and I haven’t been able to stop since.

One time we spent more than fifty minutes happily playing nothing but A Felicidade. We only stopped because his phone rang, and it was out of tune.

Looping turned out to be the perfect excuse for improvisation. It felt as though things were finally starting to make sense. The aggressive rigidity of the loop kept me caged, while improvisation set me free.

By then I had already transitioned to electric guitar, and the variety of sounds pouring out of my pedals fascinated me in a way that even the acoustic guitar, the instrument of my life, couldn’t quite match.

Years later, another friend entered the story: Ingo.

During the pandemic, we spent a lot of time talking about guitar while he was learning to play. I had recently moved and had been forced to sell my guitar and effects pedals to help pay for the relocation. Those conversations, combined with the fact that I would no longer be traveling weekly for work, motivated me to buy another guitar and start playing again.

I had kept a small loop pedal. I could finally exercise that musical muscle once more.

Missing a proper musical foundation, I decided it was time to study. I bought two courses from the Dutch guitarist, and excellent teacher, Paul Davids: one on music theory for existing players and another dedicated to looping.

A few hours into the lessons and I was already understanding the functional structure of loops while having an absurd amount of fun. The moment I realized this was exactly what my musical life had been missing, I upgraded and acquired a beautiful loop station capable of recording up to six stereo tracks per loop.

And yet, something still felt missing.

I would power on all my gear and feel a strange emptiness. As if there were something beyond music itself, something music alone couldn’t fill.

That’s when I remembered something that would accidentally change everything:

MIDI.

Reason

At their core, .mid files are musical performance manuals, except they’re written for instruments rather than musicians.

Strange, isn’t it?

Back in the early 1980s, several manufacturers were bringing synthesizers to market. An engineer and musician named Dave Smith, from Sequential Circuits, proposed something that would unite them all: a universal standard for exchanging information.

The idea was remarkably simple: send a digital message from a keyboard to an instrument.

That message could carry all sorts of commands, from which note should be played and how hard it should be struck to various parameters that could be adjusted on the receiving instrument.

MIDI was born. A digital sheet of music, for all practical purposes.

Of course, it didn’t remain confined to synthesizers. MIDI is still widely used throughout the music world, including in the ever growing pile of gadgets I was accumulating.

One of those devices was an amplifier modeler. Since space at home was limited, I opted for a modeler instead of a dozen pedals and a real amplifier. My signal was no longer purely analog. It was converted by the modeler and transformed according to whatever configuration I created in that astonishing block-filled graphical interface.

The sound was so good that I never once regretted going digital. Perhaps because I was never much of a vinyl enthusiast.

While tinkering with the interface, I noticed that many parameters could be configured to respond to MIDI messages. Not only could I add external controllers to send commands to the modeler, but I could also control it directly from my computer through an audio interface that supported MIDI.

Naturally, I started playing with automation.

Watching buttons on my computer transform into changes inside the modeler was every bit as exciting as an improvised blues solo.

And yet, something was still missing.

As I became increasingly obsessed with firing off messages, I found myself playing more and more with backing tracks. To compensate for the absence of a band, I would play songs with the lead guitar removed and improvise over the top.

The loop station ended up gathering dust.

Truth be told, my biggest problem was a lack of texture for building loops. I’ve never been particularly good at extracting a wide variety of tones from a guitar, and that limitation carried over into my loops. I tried simulating a bass guitar, but it always sounded artificial.

That’s when I remembered something else:

Synthesizers.

Another friend, Daniba, once told me that I would have an absolute blast playing with synthesizers. I found one that looked particularly interesting and bought it.

I finally understood what a synthesizer actually was.

For someone obsessed with physics, a synthesizer is a laboratory disguised as a musical instrument. It controls electrical oscillations in countless ways: shaping frequencies through filters, manipulating energy through envelopes, and generating harmonics through simulations of phenomena governed by the very same equations that describe vibration, resonance, and wave propagation in nature.

It’s a wave tamer.

Thank you again, Fourier.

As if all of that weren’t enough, it came with a keyboard that looked more like a breadboard than an actual musical keyboard. Instead of relying on key pressure, this synthesizer responded to the amount of skin making contact with the surface.

To say I liked it would be an understatement. I was completely fascinated!

The Loop That Changed the Game

One day, in 2024, I recorded a very simple chord progression and started experimenting with the synthesizer, searching for something that occupied roughly the same frequency range as a bass guitar. I recorded the low-end track, then added another synth track with an even simpler chord progression.

I set everything to play and started trying out a few guitar riffs. After recording them across three separate tracks, I moved on to selecting a drum pattern. Once everything was in place, I hit “REC” and started playing.

Halfway through the take, I had the idea of turning on the synthesizer and playing along. As the music progressed, my body instinctively took over: my left hand kept playing the guitar while my right hand continued on the synthesizer.

I carried the piece forward for nearly nine minutes.

The result?

That conversation between the guitar and the synthesizer put a smile on my ears that words simply cannot describe. I spent days listening to that recording and trying to understand what, exactly, had happened to me.

Eventually, I realized that this was my musical destiny.

Naturally, my pseudo-engineer DNA immediately began looking for ways to transform the experience into something more aligned with my personality.

For a long time, I failed to integrate all the devices in an interesting way. Everything sounded, pun intended, “far too” normal.

Using a computer to send simple commands, capture audio through an interface, and record everything on that same computer was far too reliable for my taste.

So I did what comes naturally to me.

I began sketching the first drafts of a self-contained system that I could carry outside my cubicle, plug into a wall outlet, and then hope wouldn’t melt any circuitry connected to the power grid.

And that was the birth of the L∞π∩∆rium. Or at least the birth of the idea.

The year 2024 ended on a high note, but 2025 turned out to be the worst year in my family’s history, and the project came to a halt.

We moved again, but this time I only had to sell an acoustic guitar. Everything else in my rig was compressed into suitcases.

By the end of 2025, we finally moved into a house where I could have the cubicle I had always dreamed of. It even came with two electrical outlets dedicated entirely to me.

What luxury! It was the perfect environment for the project to finally take shape.

The Project Architecture

The idea itself seemed simple enough: connect a chain of devices through two distinct channels: data and audio.

The data flow looked like this:

Looper → Foot Controller → Modeler → Drum Machine → Looper (yes, again)

To demystify the components:

• Looper: The cornerstone of loop composition. This is the device that records tracks and plays them back as I awkwardly tap-dance across its footswitches. It is also responsible for distributing the song’s tempo to every other device.
• Foot Controller: A collection of programmable footswitches capable of sending virtually any command to the rest of the rig. Each of its six footswitches can perform different actions depending on how enthusiastically it is being stomped.
• Modeler: An amplifier and effects modeler. The electrical guitar tone comes from this device. (No, the electrical guitar tone does not come from the wood, otherwise IKEA would have its own custom shop division.)
• Drum Machine: A drummer in miniature form. This device stores drum patterns and plays them back alongside the loops. It is also configured entirely through MIDI (please act surprised).

Notice that the flow starts and ends at the Looper, forming a ring of sorts. That ring is how the devices communicate. I configured the Looper to avoid the dreaded MIDI echo, where messages endlessly circulate through the ring (yes, I know which song immediately came to mind), effectively opening a portal to the grand opening of a department store’s Black Friday sale.

In the L∞π∩∆rium, the loops stay in the music.

Because the Looper acts as the metronome, it has to come first. Otherwise, the rest of the chain has no reliable notion of time.

The MIDI protocol defines a pulse known as the MIDI Clock. Every 24 pulses correspond to a quarter note. With some back-of-the-napkin math, it’s easy to see that one second at 120 BPM (beats per minute) equals 48 pulses per second (BPM × 24 / 60).

I initially ignored this little detail. I later paid a rather expensive toll in technical debt to correct that mistake.

Without MIDI Clock flowing through the contraption, the entire setup performs worse than the polychords in a car crash.

As for audio, the connections look like this:

Guitar → Modeler
Synthesizer → Modeler
Drum Machine → Modeler
Modeler → Looper
Looper → Audio Output

Although the synthesizer supports MIDI, it does not participate directly in the ring.

The reason is simple: it usually isn’t present when I take this entire pile of equipment outside my cubicle. In a ring topology, every element must be functioning for the ring itself to function. Removing the synthesizer would therefore break the system.

Instead, I connected the synthesizer via USB to a Raspberry Pi, a tiny Linux computer, which also connects to the Looper over USB to eavesdrop the messages.

The little computer serves not only as a messenger, forwarding a copy of everything traveling through the MIDI ring to the synthesizer, but also as an automated control center.

That is where the brain of the L∞π∩∆rium lives.

I installed a software called Companion to integrate with a programmable control surface, a fancy way of saying “a panel full of buttons whose behavior and appearance I can customize.” This gives me visibility into the current state of the system while also allowing me to issue commands to the entire rig.

There was only one problem:

Companion doesn’t support MIDI out of the box. There is a plugin that provides reasonably decent support.

Unfortunately, “reasonably decent” is not the same thing as “optimized for the bizarre things I want to do.”

After several failed attempts to force the L∞π∩∆rium’s thought process into someone else’s plugin architecture, I finally admitted defeat and chose the far more convenient solution:

Writing my own plugin.

That meant learning a new programming language: TypeScript.

For someone who already knows a handful of languages, learning another one is mostly a matter of deciding how much coffee the process will require.

Writing the Glue

Just as the brain reacts to stimuli, musical devices need to react to MIDI Clock as well.

The interesting thing about this characteristic is that it opens the door to an event-driven architecture, where every MIDI Clock pulse becomes an event. Better yet (or worse, depending on your perspective), once you decouple internal components through messaging, you can start building an architecture inspired by distributed systems.

Distributed systems are actually quite simple. They only have two challenges:

2- Deliver the message just once.
1- Deliver messages in order.
2- Deliver the message just once.

Simple! And things get even easier once computer networks become involved.

I estimate that roughly 84.42% of the software performance problems I’ve encountered throughout my career were caused by people underestimating just how “simple” those requirements are.

I have no intention of reaching the supreme level of architectural sadism by introducing microservices or whatever trendy nonsense greedy influencers are selling this week.

Sending messages through a shared bus keeps things loosely coupled and beautiful. Otherwise, I’d end up creating a magnificent dependency spaghetti with a very real chance of circular references.

Even I have limits.

The entire structure is driven by only two types of stimuli:

• Interactions from the control surface.
• MIDI messages.

User interactions are about as trivial as Newton’s Second Law: pressing a button causes a reaction inside the code running on the Raspberry Pi.

MIDI messages follow a similar path. They’re intercepted by the Raspberry Pi, decoded, and converted into internal messages that the various components understand and act upon.

It’s worth mentioning that the Foot Controller itself sends MIDI messages directly from within the ring. Those messages are addressed to the Raspberry Pi, which performs the same translation process.

It’s basically a diplomat.

Most MIDI messages contain a field known as the channel. It can hold values from 0 to 15, allowing each device to listen only to messages intended for a specific channel.

Every device in my setup, including the Raspberry Pi, has its own dedicated channel. I even reserved one channel exclusively for testing.

Yes, continuous testing is necessary when you’re the kind of person who builds things like this.

I implemented a sort of MIDI-based ping using that dedicated channel. The Raspberry Pi sends a predefined message to the Looper and, because it travels around the entire ring, eventually returns to where it started. If the message fails to come back within a short period of time, one of the control buttons displays a highly visible warning.

Since the primary goal is creating musical loops, MIDI Clock becomes essential for injecting additional functionality. Before anything else, however, I need to calculate the BPM represented by the incoming pulse frequency.

What’s the practical value of that?

Almost none.

Other than displaying it on a control button so I can confirm that all devices agree on the tempo.

The truly important part is synchronizing actions so they occur on precisely the desired clock pulse.

Value transitions, for example, become significantly smoother if a parameter changes slightly on every clock event until it reaches its target value.

But remember those 48 pulses per second at 120 BPM?

Exactly! Imagine 48 events per second triggering various processing tasks inside a tiny computer the size of a credit card.

CPU utilization occasionally climbed above 50%. That’s when I decided to apply a flow-control strategy, or just throttling.

I drastically reduced the number of stimuli. For every 12 MIDI Clock pulses received, a single internal stimulus is generated and delivered to the components. That effectively reduces everything from 48 events per second down to a mere 4.

In the end, two internal pulses, which I’ll refer as ticks, become equivalent to a quarter note, replacing the original 24 MIDI Clock pulses.

With that solved, it was time for phase two:

Measure synchronization.

Fortunately, the drum machine I use transmits measure information via MIDI. Since another MIDI message is also sent whenever a loop begins, I have all the ingredients required to track the musical timeline with complete precision.

Let’s assume a song is written in 4/4. Since each tick represents an eighth note, half of a quarter note, the measure changes every 8 ticks.

Once I define the number of measures in a loop, some very interesting automation becomes possible. For example:

• During the final measure of a loop, the drum machine can perform a fill or transition.
• At the beginning of the next loop, different tracks can automatically start or stop.
• The mix of whatever I’m currently playing can change with each loop, shifting left and right in the stereo field while simultaneously adjusting volume levels. This allows me to control the entire soundstage during a performance.

And it gets even better!

Because I control the code, I can embed all relevant information about my loops directly into the system itself. That enables me to create automation structures that perform exactly the right actions at exactly the right moments.

My first test case was All In Hands, a piece by Franck Duhamel, the creator of Guitar Pro. The song is built around a chord progression that repeats every 24 measures. I recreated the loop using guitar and synthesizer, then implemented automations that changed guitar effects, started and stopped tracks according to the song’s progression, triggered drum fills, and generally handled every detail required to reproduce the piece in an automated performance.

At the same time, I could disable the automations whenever I felt like wandering freely through the harmony.

I still tinker with the code constantly, but I’ve long since crossed the point where the system is reliable enough for me to perform without worrying about anything other than the traditional challenge of playing everything right.

It’s hard to imagine buying a commercial product that would give me this level of freedom. Using Open Source Software such as Linux, Companion, and everything else that allows my Raspberry Pi to deliver so much value was exactly the missing piece that brought this project to life.

Like any software project, this contraption will never truly be finished. But it will always be ready.

Was it a lot of work? Of course.

Was it worth it? Absolutely.

And that, by the way, is the true beauty of Open Source. It’s free of cost, not free of effort.

Behind that effort lies the freedom to modify, adapt, and shape everything to fit your own needs, and that freedom alone is enough to dwarf any paid alternative.

At least for someone like me.

The Control Panel

Well, what would all this madness be without some way of at least knowing what’s happening inside?

The control surface I use consists of a matrix of buttons arranged in four rows and eight columns. I organized everything so that the first row and first column remain common across all four main panels. Hidden behind the L∞π∩∆rium logo is a special debugging panel where I can fire off MIDI messages and verify whether what I programmed is actually working.

Spoiler: it almost never is, which is precisely why I built the damn panel.

This is the main panel, the place where loop creation begins.

I select one of the sixteen drum patterns mapped inside the Drum Machine and choose the loop template corresponding to the correct time signature. My Looper doesn’t allow changing a loop’s time signature via MIDI, so I ended up creating separate templates for each one.

Incidentally, this is one area where my Looper leaves a lot to be desired.

Parameters must be configured individually for every loop. Since I standardize everything, that means whenever I come up with a new idea, I have to update all templates and every loop I’ve already saved in memory.

This is my Looper view.

From here I can see a brief description of each of the six tracks, enable loop automation so I can focus entirely on playing, and monitor the loop’s progression measure by measure.

Here I have access to the Modeler.

In practice, I mostly need to know which tone configuration is currently active and where that sound is positioned within the mix.

That position can vary depending on the tone itself. A heavily distorted guitar might sit further to the right, while a cleaner sound may live further to the left.

And yes, the positioning is actually two-dimensional.

Increasing an instrument’s volume effectively moves it forward on the soundstage.

This allows me to create much richer loops. I can record two guitar riffs using slightly different tones and place them on opposite sides of the soundstage.

This is probably the panel I use the least.

The Drum Machine is so tightly integrated with the Looper through my plugin that I rarely need to interact with it directly.

From here I can change drum kits, navigate the pedal’s menus, and modify how drum patterns fit into the musical tempo.

And that’s actually one of my favorite features.

Let’s say I’m playing a loop at a given tempo. If I double the playback speed of the percussion, the tempo remains perfectly synchronized. One measure of the loop now contains two measures of percussion, but everything still lines up. The same thing happens if I cut the percussion speed in half. In that case, two loop measures are filled by a single measure of percussion.

Pure mathematics.

This becomes especially fun when combined with fills and transitions, which is why I usually keep those controls readily available on the Foot Controller.

There’s a good chance I’ll replace this panel with something more interesting someday. Perhaps a larger loop overview with more detailed measure information.

Once again, that’s the beauty of having complete control over what’s happening under the hood.

This is the debugging panel.

I primarily work with two types of MIDI messages:

• Control Change (for parameter adjustments)
• Program Change (for switching memory banks)

Whenever I need to test an integration between devices, I can simulate message transmission directly from here.

I even mapped the MIDI channels for every device to make my life easier.

The shared elements across all four panels have gone through countless revisions. For now, the following information serves me well:

• Raspberry Pi CPU and memory consumption
• Current instrument position on the soundstage (guitar or synthesizer)
• Measure information reported by the Drum Machine
• Tempo in BPM, calculated from MIDI Clock, and, if I’m currently inside a loop, which bar and beat I’m on

Wait a second… “If I’m currently inside a loop”?

Are you saying this thing does other stuff too?

How dare you betray your own identity?

Easy there.

Remember how I mentioned enjoying soloing over backing tracks that were missing the lead guitar?

Well, I reserved several Looper memory banks specifically for that purpose.

I loaded them with songs from artists and bands I love, Joe Satriani, Led Zeppelin, Eric Johnson, Santana… as well as backing tracks created specifically for jamming, such as those from JustinGuitar.

Since each loop contains six tracks, every memory bank effectively gives me six songs that can be launched from the pedals.

The problem is that I can’t guarantee tempo stability in those recordings. In fact, I hope the tempo changes.

The most human element in music is precisely that subtle variation. Removing it turns music into something robotic and soulless.

Granted, the deterministic grid of a loop absolutely embodies that robotic and soulless side. But if I were playing with an actual band full of actual humans, I would never hire a Drum Machine as the drummer and ruin the whole thing.

I might eventually implement a system based on elapsed time itself, actual seconds rather than beats, but I haven’t felt the need yet.

Okay, okay. There’s a very high probability I’ll implement it within a few days. I simply cannot have an idea without immediately putting it into the testing pipeline. That’s the real joy of having a musical and technological laboratory like this one:

Validating ideas becomes a rewarding part of the journey itself.

Why L∞π∩∆rium?

By now you’re probably wondering why on galaxy this thing is named after what appears to be a mathematical panic attack.

The name contains several layers of meaning that, together, tell a story: the story of a signal entering a mysterious place, passing through a beautifully chaotic system, and somehow making it safely out the other side.

The first layer is formed by the symbols themselves. And that’s where the story begins.

The initial “L” represents the raw signal coming from my guitar (and, hopefully, from an acoustic guitar soon as well). The letter stands for the clean signal used to build the deterministic structure of the loops.

The “∞”, the symbol for infinity, represents the Looper itself.

The signal arrives there, where it is combined with the percussion coming from the Drum Machine and can be stored on one of the tracks.

It is my deterministic cage, a place that, paradoxically, provides a safe and rational environment for emotional expression.

The “π”, the Greek letter Pi, represents the Raspberry Pi. The chaotic core of the entire structure, endlessly attempting to orchestrate everything.

The “∩”, a symbol used in set theory to denote intersection, represents the software layer I built on top of Companion: the point where MIDI messages converge and are translated into information that allows the various components to perform their respective roles.

The “∆”, the Greek letter Delta, represents variance. It is primarily associated with the synthesizer, symbolizing the domestication of waves, seasoned with the subtle variations introduced through skin contact.

Truthfully, this element also represents the small fragment of humanity present in the entire system:

Me.

As I mentioned earlier, those tiny variations introduced by human beings are what give music its soul.

Finally, “rium” represents the return to normality. The resolution of everything.

Despite resembling an unstable molecule, the system ultimately processes and routes the audio toward its long-awaited stereo output.

The second layer is somewhat more philosophical.

The term Loopinarium intentionally echoes vivarium, a Latin-derived word meaning something akin to “a place of life.”

A vivarium is an interdependent system. A closed environment where different organisms and elements interact in ways that sustain the ecosystem as a whole. It is, in essence, the cultivation of life.

And finally, there is an even deeper layer.

Hidden inside the word Loopinarium, more specifically within the sequence of symbols π∩∆, lies my ultimate pun:

“pina.”

Or rather, pinna.

In anatomy, the pinna is the external part of the ear. It is the structure primarily responsible for helping us determine the direction of a sound source.

Which means that, buried deep inside a bizarre hybrid of mathematics, music, software architecture, and questionable life decisions, there is a tiny tribute to the very thing that makes all of it worthwhile:

Listening.

Conclusion

At the end of the day, this isn’t just a piece of musical equipment. This is:

• a loop engine
• a rhythm engine
• an effects and tone engine
• a chaos engine
• a middleware layer
• and a user interface

All loosely coupled, mildly synchronized, and held together by duct tape, zip ties, MIDI messages, and highly questionable confidence.

In other words:

Something perfectly normal for someone like me.

I just hope it compiles.