Here is the demo for p5js with tidal cycles:
For this project, I wanted to place strong focus on the drum patterns in my music. In the first section, I used a central rectangle and changed its form through twisting and scaling. These transformations were chosen to represent different shifts and spikes in the drum beats. By distorting the rectangle, I tried to show how the percussion moves and grows during the track. This is a big challenge since it is hard to find the values that exactly match the strengths and the frequencies of the drums.
When the piece reaches its middle section, I remove all the drum parts after a brief lead-in and leave only an ambient synthesizer. I also take away the moving rectangles in the center to keep the visuals in step with the music. Afterwards, the bass brought some energy to the piece, and made me think of adding some glitchy patterns in Hydra together with some crushing and distorted sounds.
In the final section, I used only a Moog synth. I wanted the sound to be stretched out and slow to fit the outro of the entire composition and to make it stand apart from the earlier chaotic bass lines. I also adjusted the pattern to be more organized, and it shifted in step with the Moog as it gradually slowed down.
Code for Hydra:
shape(
() => 3 + Math.floor(cc[0] / 10),
() => 0.2 + cc[0] * 0.001,
() => 0.1 + cc[0] * 0.0005
)
.modulateRotate(
noise(
() => 2 + cc[0] / 10,
() => 0.3 + cc[0] * 0.001
),
() => 0.3 + cc[0] * 0.003
)
.out(o0)
shape(
() => 3 + Math.floor(cc[0] / 10),
() => 0.2 + cc[0] * 0.001,
() => 0.1 + cc[0] * 0.0005
)
.modulateRotate(
noise(
() => 2 + cc[0] / 10,
() => 0.3 + cc[0] * 0.001
),
() => 0.3 + cc[0] * 0.003
).layer(
shape(
() => 4 ,
() => 0.15 + cc[1] * 0.008,
0.02
)
.rotate(
() => (time * 0.05) + (cc[1])
)
.colorama(() => cc[1] * 0.1)
.scale(() => 1 + cc[1] * 0.002)
.luma(0.2, 0.1)
)
.out(o0)
src(o0)
.layer(
shape(
() => 4 ,
() => 0.15 + cc[1] * 0.008,
0.02
)
.rotate(
() => (time * 0.05) + (cc[1])
)
.colorama(() => cc[1] * 0.1)
.scale(() => 1 + cc[1] * 0.002)
.luma(0.2, 0.1)
)
.out(o0)
src(o0)
.layer(
noise(
() => 1 + cc[2] / 20,
() => 0.2 + cc[2] * 0.001
)
.rotate(() => cc[2])
.kaleid(() => 2 + Math.floor(cc[2] / 20))
.colorama(() => cc[2]*3)
.luma(0.3, 1)
)
.layer(
shape(
() => 4 ,
() => 0.15 + cc[1],
0 // change to 0 after silence
)
.rotate(
() => (cc[1])
)
.colorama(() => cc[1] * 0.1)
.scale(() => Math.random())
.luma(0.2, 0.1)
)
.out(o0)
src(o0)
.layer(
noise(
() => 1 + cc[2] / 20,
() => 0.2 + cc[2] * 0.001
)
.rotate(() => cc[2])
.kaleid(() => 2 + Math.floor(cc[2] / 20))
.colorama(() => cc[2]*3)
.luma(0.3, 1)
.rotate(
() => (cc[1])
)
.colorama(() => cc[1] * 0.1)
.scale(() => Math.random())
.luma(0.2, 0.1)
)
.out(o0)
hush()
osc(
() => 10 + Math.random() * 20,
0.1,
() => 0.8 + Math.random() * 0.2
)
.modulate(
noise(
() => 2 + Math.random() * 3,
() => 0.1 + Math.random() * 0.05
)
)
.rotate(
() => time * 0.05 * Math.random()
)
.out(o0)
src(o0)
.layer(
shape(() => 3 + Math.floor(Math.random() * 5), 0.2, 0.05)
.scale(() => 0.8 + Math.random() * 0.4)
.luma(0.4, 0.1)
.rotate(() => Math.random() * 2)
.colorama(() => Math.random() * 2)
)
.rotate(() => cc[3] * 0.03)
.kaleid(() => 2 + Math.floor(cc[3] / 15))
.colorama(() => cc[1] * 0.1)
.scale(() => 1 + cc[3] * 0.001 + cc[3] * 0.001)
.out(o0)
solid().out()
Code for Tidal:
d1 $ s "arp:3*4" >| note (scale "<major>" ("[<-2 -5 -1 -3>,2](3,8)") + "c7")
# room 0.4
# krush 6
# lpf 100
# gain 1.5
d2 $ ccv "<40 60 80 100>"
# ccn "0"
# s "midi"
d3 $ s "bass*4" >| note (scale "<major>" ("[-5,2](3,8)") + "c4")
# krush 8
# lpf 100
# gain 2
# legato 2
# room 0.4
d4
$ struct "t*4"
$ ccv "<30 60 90 120>"
# ccn "1"
# s "midi"
d3 $ s "bd:3(2,8) bd:3(3,8)" # krush 6 # gain 2 # legato 2
d5 $ struct "<t(2,8), t(3,8)>"
$ ccv "<40 80 10 120 150>"
# ccn "2"
# s "midi"
d4 $ s "arp:5*4" >| note (scale "<major>" ("[<-2 -5 -1 -3>,2]") + "c4")
# lpf 200
# krush 4
# gain 1.5
# legato 2
d3 silence
d3 $ s "808bd:3*4" # room 0.7 # krush 6 # gain 1.2
d3 $ qtrigger $ filterWhen (>=0) $ seqP [
(0,1, s "808bd:3*4"),
(1,2, s "808bd:3*8"),
(2,3, s "808bd:3*16"),
(3,4, s "feel:6(3,8)")
] # room 0.7 # krush 6 # gain 1.2
boom = do
d1 $ qtrigger $ filterWhen (>=0) silence
d2 $ qtrigger $ filterWhen (>=0) silence
d3 $ qtrigger $ filterWhen (>=0) silence
d4 $ qtrigger $ filterWhen (>=0)
$ s "<feel:6(3,8), feel:6(5,8,1), feel:6(3,8)>"
# room 0.85
# speed "<1.2 0.8>"
# gain 1.2
# krush 3
# pan (slow 4 sine)
boom
d5
$ s "moog"
# note (scale "aeolian" (irand 8))
# sustain 8
# release 8
# gain 2
d4 silence
d7
$ struct "t"
$ ccv "<30 60 90 120>"
# ccn "3"
# s "midi"
hushThis is the video for my current progress of composition. For this work the music is not very structured and I am still trying to figure out how to make it proceed more smoothly.
Dissected, “de-natured,” and distilled into abstract sounds and images, natural phenomena become eccentric compositions, revealing the wonders contained within.
Ryoichi Kurokawa’s artistic approach reminds me of deconstruction—the process of breaking down natural forms, sounds, and movements into abstracted components before reassembling them into new configurations. His work does not aim to capture nature as it appears to the naked eye; rather, he dissects it, isolates its underlying structures, and reconstructs it through audiovisual synthesis. This act of deconstruction is not about destruction but rather about rediscovery, revealing hidden layers of complexity that are often overlooked in everyday perception.
In Octfalls, Kurokawa takes the movement of water—something familiar and continuous—and deconstructs it into disjointed yet synchronized audiovisual fragments. The cascading motion of waterfalls is translated into sharp, digital interruptions, reframing the fluidity of nature as something mechanical, algorithmic, and layered. In this process, he distills the essence of motion rather than merely illustrating it, allowing the audience to experience nature in a new, mediated form.
This act of reconstruction aligns with the Japanese aesthetic concept of wabi-sabi, which values imperfection and the beauty of decay. Kurokawa’s work does not seek to present a polished, idealized version of nature; instead, he embraces its instability and unpredictability. His compositions often feature glitches, distortions, and irregularities, mirroring the natural world’s inherent disorder. Through deconstruction, he does not strip nature of its essence but rather uncovers its transient, ever-evolving nature, which keeps the audience continuously engage in the nature system.
In my research project, I explored FoxDot. FoxDot is a live coding platform with Python and SuperCollider. The platform is designed for improvising and composing music, which is similar to Tidal Cycles. The significance of FoxDot is its Python driven environment, and is the major reason why I chose this platform: I am more familiar with the syntax of Python.
One Fun Fact Discovered While Researching:
The creator of FoxDot, Ryan Kirkbride attributes the inspiration of building a live coding platform to Alex McLean, the creator of Tidal Cycles and the term algorave. It turned out that Alex McLean mentored Ryan Kirkbride in the computer music field when he was pursuing his master degree.
Why Python?
With FoxDot I wanted to create an application that bridged the gap between software engineering and Live Coding so that users who were entry level to programming, composition, or both would still be able to grasp the concepts and make music.
What makes Python stand out? First is its object oriented programming. The object oriented design makes it easier to trace the current states of different variables as the image showed below:
The changes applied to p1 can easily be tracked based on the output showed on the terminal. Its clean syntax helps both live coders and the audiences to follow the code. A wide range of third-party libraries greatly expands what live coding can achieve. For example, tkinter package to build a customized GUI; extensions that can support Sonic Pi, voice renderization…
From a beginner’s perspective, the rapid auto-completion feature significantly improves coding fluency. This responsiveness is a notable advantage over platforms like Tidal Cycles, which can be laggy in practice.
Cultural Impact
Broad compatibility expands creative expression. FoxDot works well with many libraries and software tools, allowing artists to mix different digital resources and create unique audiovisual experiences.
User-friendly language lowers the learning curve. The simplicity of Python as the programming language makes it accessible to beginners and non-programmers, lowering the barrier to entry and encouraging more people to engage in live coding.
Creates a large live coding community. By making live coding more approachable, FoxDot has built a sizable and active community. This community supports idea sharing and collaboration, drawing a diverse range of artists and enthusiasts into the live coding culture.
Demonstration of Performance
The following video is me trying to play with some functions and effects in FoxDot:
Electronic music has long been entangled in a debate about its humanity—whether it lacks the “soul” that traditional acoustic music embodies. However, as history has shown, electronic music is not detached from human expression; rather, it continuously interacts with historical and cultural narratives, reshaping the way we perceive sound, memory, and identity. From the early drum machines like the Roland TR-808 to modern synthesizer-based music, electronic sounds have evolved from mere functional tools into carriers of nostalgia, cultural significance, and artistic innovation.
One of the most striking examples of electronic music’s transformation is the Roland TR-808 drum machine. When it was released in the early 1980s, it was considered a cheap, artificial alternative to real drummers. The machine’s rigid quantization and synthetic drum sounds lacked the microtiming and organic fluctuations found in human performance. Because of this, many in the traditional music industry dismissed it. However, the TR-808 did not disappear. Instead, it found a second life in genres like hip-hop, house, and techno. For early pioneers in these genres, a cheap yet powerful tool for production was preferred. This historical background introduced them to the drum machine and its futuristic sound.
Another way electronic music gains its “soul” is through the use of samples, where producers incorporate fragments of existing recordings into their compositions. Renowned artists like Daft Punk, Jamie xx, Fred again.., and The Avalanches have mastered this technique. I remembered that in a Pitchfork interview with The Avalanches, the group mentioned their passion for western movies, and adopted the horse sound as a recurring sample in their album Since I Left You. This approach demonstrates how sampling is not merely a technical tool but a form of musical storytelling—one that connects generations of sound and reimagines stories behind the artists.
The concept of “liveness” in live coding, as discussed in the article, offers a chance for me to rethink what it means to live: “to have bodies, to communicate, to act.” By blending the real-time creativity, improvisation, and certain kinds of performance, live coding challenges conventional notions of both coding and human-computer interaction. It encourages us to think beyond code itself. What we need to emphasize are the human thoughts and contexts that are included while performing.
Live coding uniquely frames coding as a public performance, where the audience witnesses both the creative process and its immediate output. Unlike traditional programming, which often happens behind closed doors, live coding reveals the coder’s thought process, mistakes, and decisions in real time. This openness highlights the coder’s humanity and makes it different from the polishness that is featured in a written program. That is why live coding is an act of communication not only with the machine but also with the audience.
Live coding also makes me think differently about what it means to be “live” in today’s digital world. By showing coding as it happens, live coding pushes back against this invisibility and invites people to actively participate, even if they’re just watching. It reminds me that being “live” is about being present, involved, and taking action—an important idea in a time when digital interactions often focus more on efficiency than real connection.