Magpie (Part 1)

Magpie is a livecoding tool that I've been making, for doing visual performances at algorave events. It's made using Picotron, a 'fantasy computer' designed to mimic computing in decades past. I have some really cool things I want to do with it in 2026, but since I'm just showing it for the first time I wanted to write a little about why I made it, what it is, and how it works. This post is about what can do right now, as well as what words like 'livecoding' and 'Picotron' mean, if you don't know, as they're not very common things!

What is Livecoding

Very broadly: livecoding is people making music and visual performances using special tools which are often controlled using code. When we say 'code', it's less about programming in the sense of 'learn to code'; it's more about using the languages and styles of coding as a way of describing big, unpredictable or complex things. Livecoders don't normally write 'good' programs, or have lots of complicated logic, or engineer big systems. Often it's about chaining together simple ideas that create something big and impactful. Here's a little clip of someone livecoding music that went viral in 2025:

Livecoding is often improvised - but doesn't have to be - and it covers a wide range of styles. Musically, an average algorave might include soft ambient soundscapes, crunchy experimental noise, sliced and sampled hip-hop, trance, all sorts. Visually it's a little more constrained, but you might see people doing weird things with graphics shaders, oscilloscopes, 3D models, or video feeds. One memorable livecoding set I saw was pulling in clips from Shrek and performing strange graphics processing on top!

It's quite common for livecoders to make their own tools to perform with, in fact it's something of a running joke in the community that everyone does this eventually. I actually didn't think I would, because I've not been one for making my own tools or game engines in the past. But this year I kept thinking about things I wish other tools did, and then I had a few thoughts/inspirations come together all at the same time to make me energised enough to make this. So here we are!

What is Picotron

Picotron is a mini-computer, that runs inside your computer. When you load it up you see a desktop, files, folders, just like Windows or MacOS, and you can make things in it including text documents or pixel art. It's especially good at making games, it has a sprite editor for making art, and a music editor for making sounds - it's from the people who made PICO-8, which is solely focused on games, so they share a lot of philosophies. They are both 'fantasy' platforms, meaning that they mimic the restrictions of technology from other eras. For example, Picotron only has 32 colours in its palette, and the display resolution is 480x270 pixels - that's probably a lot smaller than the screen you're reading this on now (you can find some of my PICO-8 games here).

Restrictions are interesting because they can encourage you to get creative to get the most out of them (here's DOOM running in PICO-8, for instance) and they can also encourage you to make small things that are well-scoped (very useful for people like me). Adam Saltsman recently made a beautiful series of videos talking about how PICO-8 shaped his personal philosophy around game design. However, PICO-8 and Picotron are also very comforting tools to work with. They contain everything you need to make a game, including art, music and coding tools; things made with them are open-source by default which lets you share with and learn from others; and they run on old machines, web browsers, they don't need a lot of power. So there's a lot to like about the aesthetics and feel of working with it, too. Using Picotron is cosy, for want of a better word.

What is Magpie

Magpie is a tool for livecoding visuals, written for Picotron. You run it like a normal Picotron program, but then you can write code that creates your performance. Here's me starting up Magpie, and then writing a line of code to make some circles appear:

Notice how my code appears on top of what I am making - this is very common in livecoding tools. People watch the output and the code at the same time. You can also hide the code entirely to see what you've made more easily. This is quite important for Magpie because unlike other livecoding tools I can't really make the code smaller than it is. We only have 270 pixels of height to work with, and the font we use is 8 pixels high. The code rapidly takes up a big chunk of what you're looking at! Here's a longer example, you can see how busy it gets quite quickly (admittedly I padded this out a bit to make the point):

Right now, Magpie has a very small set of features as I've not been working on it for long, and most of the work I did was just setting it up to be functional enough to use! Here are some of my favourite features that I've implemented so far. First, it has a few different ways to clear the screen. You might commonly clear the screen every 'frame' (which happens 60 times a second in Picotron) before drawing things on the screen. But there's many ways to clear the screen, including using patterns (like scraping the old pixels off with a metal brush) or randomly splotching pixels on it. Look at difference between these examples below. First, clearing the screen normally:

This just looks like normal moving objects, because clearing the screen completely is what you normally do when making things like games. Compare to this, where we're clearing the screen by painting over it with a pattern that slowly covers the old drawing:

Finally, clearing it by randomly splatting pixels onto the screen. We can change the speed at which this happens to intensify the effect:

By default, Picotron does not clear the screen after it draws a frame, so we can take advantage of that to create interesting effects, save on computation, and make fun messes.

I've also added ways to integrate timing into things you make with Magpie. Let's say we have a ball bouncing up and down - we might want it to bounce exactly on a drum beat, so people watching the performance feel the connection between the sound and the visuals.

Most tools do this by having you type in what speed or bpm (beats per minute) you are performing at, and then adjusts your code's timings to fit. Some tools can listen through a microphone and react to the music that way. Something I thought was really cool, though, is a feature I saw in a livecoding tool whose name I now can't remember. It let you tap the spacebar and it would detect the BPM. This is a great compromise for Magpie, since we don't have microphone input and it feels a bit more expressive. So I added that! You can turn the sound on for this one to hear how I try to sync the timer to the beat:

The yellow circles are the timing tool, which can be toggled on to appear on top of your code (in this case my 'performance' is the little expanding/contracting blue rings). In the example here, I've tied the size of the field of blue rings to the timer, so as I change it they move faster, and then slower again. In the latter half of the clip I try to sync it to half the speed of the main beat. It's not the best example of how it works but hopefully you can get a little sense for it.

One thing I like about listening to microphone input, though, is that it can detect more complex noises in melodies or drum patterns. So I took the beat timer idea an extended it a bit. Magpie has a pattern maker too, where you can tap the spacebar in a rhythm and create more inputs for your sketch that aren't just regular beats. This can be really good for syncing up with specific subpatterns! The drums in this clip have a 1-2-1-2-3 rhythm (strobe warning for this one in particular):

The pattern timer in particular needs tweaking to fit into code more naturally, but I like the way the interaction works, and it feels natural and expressive to use - again, using the spacebar to punch in blobs, and feeling the right moment to stop the pattern which makes sure it loops right.

These are just some of the first things I've put into the tool, but I have many things I want to try and add to see how they help/feel, and I'm finding more ideas as I make it. I won't write any more here to avoid it becoming documentation! I don't know if I'll update Magpie forever and ever, but I will at least clean up some parts and add a few new features as I use it more and hopefully perform with it.

What Next?

I'm hoping to get an early version of Magpie published in January. I doubt many people will want to use it as their main livecoding app - the tool is a bit clunky to use, and right now at least it's very easy to break or to lose all your code. It's also missing one or two major quality of life features, like being able to highlight code with your mouse, or cut/paste. These aren't too hard to add, but because I'm mostly making it for myself it's tempting to just avoid these features because they aren't very fun to code and I can live without them! I will try and find the energy/interest to make it easier to use though.

I also have one or two other blog posts I am thinking of writing about Magpie, one to discuss my thinking about visualisation tools, and another to lay out more of Magpie's features/controls more in the way of documentation. I have some extra features I want to add, probably after the initial release, and I'd also like to record a ten-minute set or some example of it being used too, probably to coincide with the release.

I have a really fun idea for a set I want to do with Magpie, so after that I will prioritise adding the features I need for that. I'm hoping to debut that at Algorhythms in February, so if you're in London do keep an eye out for that! In the meantime, if you have questions or comments about Magpie please ping me on bluesky or join my Discord.