Project statement
Looping as memory rather than repetition
Timelinefree Looper was designed to let recorded gestures return according to performance decisions instead of a predetermined song grid.
The Max/MSP patch uses multiple buffers and independent play/record chains to capture short soundbites, restart them and layer them asynchronously. MIDI pedal control keeps the hands free and turns recording, recall and accumulation into instrumental actions. The result is a live structure in which cycles can coexist without being forced into one common timeline.
System anatomy
Independent memories inside one performance
The design separates capture, playback and physical control so that every layer can acquire its own duration and relationship to the present gesture.
Multiple buffers
Separate memory areas hold different soundbites, allowing captured material to remain independent rather than being flattened into a single loop.
Record and play chains
Dedicated paths distinguish the act of capturing a gesture from the act of recalling it, making each stage available to performance control.
Asynchronous durations
Layers can repeat according to their own lengths. Their relationships continually shift because no master timeline forces their cycles to coincide.
Restart and recall
A soundbite can be brought back as a structural marker, interrupted phrase or recurring memory without reconstructing an arrangement.
Layer accumulation
Independent loops form temporary densities. The performer can hear alignments appear, dissolve and return as the cycles move through one another.
MIDI pedal control
Foot control translates recording and playback commands into physical gestures, keeping attention on the instrument and the evolving sound field.
Form without a master grid
Removing a shared timeline lets duration emerge from the recorded gestures themselves. Structure is heard through recurrence, density and changing phase relationships.
The body remains in the loop
MIDI pedal operation keeps capture and recall connected to live phrasing. The software stores and returns sound, but the performer decides when memory becomes form.
A loop can be a clock, but it can also be a memory that returns with a different meaning each time.
I wanted to move away from looping systems in which every gesture immediately becomes part of the same metric architecture. Independent durations create a more fragile situation: coincidences cannot be completely planned, and attention shifts from maintaining a grid to recognising when several memories suddenly form a new phrase together.
- How can independent loop lengths generate form without losing performative clarity?
- What makes a repeated sound feel like memory rather than mechanical recurrence?
- How many simultaneous layers remain musically readable?
- How can pedal gestures map naturally to capture, recall and interruption?
- Can asynchronous cycles support improvisation without becoming rhythmically arbitrary?
- What visual feedback is necessary without pulling attention away from listening?