We conceived this initial research workshop as small and only with invited participants, but we have moved it to a slightly larger venue so may be able to squeeze in further participants — please get in touch if you are interested in taking part.

Here follows the blurb and participant list:

Natural Language as Heritage Code, Sheffield 20th-22nd April 2026

At first glance, programming languages and natural languages seem fundamentally different. Programming languages are primarily used by humans to instruct computers, while natural languages facilitate human-human interactions. Natural languages evolve through history, geography, and culture, exhibiting rich diversity. In contrast, programming languages exhibit limited variation and are primarily text-based, unlike natural languages which are expressed through speech, writing, signs, and gestures.

This workshop will explore whether a unified perspective on natural and programming languages is possible. We aim to explore how such a perspective can challenge existing research in creative/live coding and linguistics. We hope this will help establish a new interdisciplinary field where languages—both natural and programming—are conceptualized as heritage codes.

We will bring together researchers and practitioners in linguistics, live coding (live use of programming languages in the creative arts), and artistic research, approaching coding languages as tools for human-human interaction, potentially in the context of indigenous/non-western language contexts, and for the purposes of human expression through music and dance.

Day 0 – 20th April 2026
Evening: concert

Day 1 – 21st April 2026
A day focussed on introducing ourselves, and finding common ground between our fields of linguistics, programming language research, artistic research, live coding practice etc.

• Orientation and introductions
• Working together to locate interdisciplinary contact points and marking out minefields(!)
  We can share and explain the meaning of key words and ideas from our own disciplinary perspectives.
• Brainstorming – what are the correspondences and differences between natural and programming languages?

Day 2 – 22nd April 2026
Connecting the fringes: How can we open up and connect linguistic and programming language research from diverse perspectives e.g., via indigenous/non-European languages and linguistic theories of dance/music? We’ll explore topics through four sessions, each prefigured by two ten-minute talks:

• Linguistics and liveness in poetry/writing
• Indigenous languages
• Choreographic/dance language
• Drumming languages

Participants

• Wataru Uegaki
• Ray Morrison
• Pritty Patel-Grosz
• Lizzie Wilson
• Kate Sicchio
• Janani Suresh Ram
• Emma Cocker
• Elin McCready
• Brandon Hinds
• Alex McLean
• Alan Blackwell

Funding

Made possible due to the support of a FLF devnet crucible grant, and UKRI FLF grants “Logic in semantic universals” and “Algorithmic Pattern”.

After a bit of time off from weaving after the PENELOPE project, it was great to visit Kristina Andersen, Pei-Ying Lin, Femke Vorselen and co in Wearable Senses lab in Eindhoven last year and explore hacking the TC/2 loom. This got me keen to get deeper into weaving, and I remembered Laura Devendorf enthusing about thinking in terms of shafts, and so we acquired a second hand 8-shaft table loom for the Alpaca project. Before I’d only really woven on looms where you control threads independently (in particular the TC/2, and my handmade live loom), which is often not how traditional weaving works. It might seem a bit strange to go from full control, to only lifting threads in eight groups of threads, but I suppose that’s how creativity works – finding constraints and playing with them.

The loom arrived, as a wooden construction with a few special-use tools and other textile and cardboard items. Luckily my cool expert weaver friend Seiko Kinoshita was happy to get me started, showing me how to make a ‘warp’ (set of vertical threads), transfer it to the loom and thread it up – this took over a day but it probably would have taken me a week or so to figure it all out myself, with chaotic results. You might see a ‘cross’ in the threads in the photo, where threads alternate going under or over the pegs either side. This cross keeps threads in order, and if at any point the cross were to get lost that’s really game over. You also have to take care to maintain even tension throughout the warp – warping is a kind of artform in its own right! You’ll also see we decided to have a striped warp, alternating through colours in groups with some symmetry.

For more info about setting up a table loom, you could check on Dave’s tutorial that he made during our last-but-one “weaving codes, coding weaves” project.

When choosing a loom, I assumed a “table loom” was one that you placed on a table, and a “floor loom” is a larger one that you placed on a floor. This isn’t the core difference though — a floor loom is one which is operated with foot pedals, known as “treddles”. This actually changes the logic of the loom, because treddles are often tied to more than one shaft — this allows you to drastically simplify the patterns of movement needed to weave a complex pattern. The pattern in which you tie treddles to shafts is known as the ‘tie-up’. I’m not completely sure why table looms can’t have more than one shaft tied to each hand-operated lever, but it might just be down to it being too heavy.. After all, weaving operations have to be ergonomically tuned to the body, because you have to perform them repeatedly, thousands of times over many hours in order to produce cloth. It’s interesting how these decisions around the binary logic of the loom is grounded in the body in this way.

Seiko and I initially threaded the loom with a direct warping – with the first warp thread attached to the first shaft, the second to the second shaft and so on, wrapping round so the ninth thread is attached to the first. This means that you have full control over the warp threads, but also that the pattern must repeat every eighth warp. So before I started to weave I decided to change it to a ‘point threading’. This starts off the same – threaded to shafts 1, 2, 3, 4, 5, 6, 7, but then continues back 8, 7, 6, 5, 4, 3, 2. Accordingly, the pattern repeats every fourteen warp threads. What you gain in the width of the repeat, you loose in control – the first 7 threads are always the mirror image of the second 7 threads. If you like symmetry, then this is a win! But here you begin to understand why there is so much symmetry in weaving – not only does it look great, but it is also a consequence of the logic of the loom.

Above you can see the patterns I began with – first a pattern of chevrons, each 14 threads wide, which is basically a direct transfer of the threading to the cloth – I was simply raising one shaft in turn for each horizontal ‘weft’ thread. Then I tried a ‘waffle’, a simple yet fascinating pattern that creates this (at first) surprisingly very three dimensional structure from the otherwise two-dimensional pattern of shafts and lifts. This is often seen in tea towels.

I was particularly happy with the above pattern, which has a long weft repeat because the ‘lift plan’ advances slowly in a sort of zig-zag pattern across the shaft levers.

As I was just getting into all this, I had to say goodbye to the loom for a while, for a trip back to Eindhoven to visit Kristina, Pei and Femke again, along with a newer research student Helen Milne in the Wearable Senses lab. We wanted to explore ‘multi-user weaving’, but of course shaft looms also entered the agenda. They have a nice range of looms in their collection, including table looms but our focus was still the computer-controlled TC/2, because we wanted to continue exploring the potential for live interaction through digital weaving. What we ended up doing though is making a shaft loom simulation for the TC/2.

The interface is shown below, and will be familiar to any weaver — the threading is shown across the top, the ‘tie up’ in the top left, the ‘treadling’ in the left, and the resulting ‘draw down’ in the centre. The draw down could be seen as representing what the fabric will look like given a warp of one colour and a weft of another colour. This isn’t really true – it doesn’t account for the three dimensional behaviour of the resulting cloth, you might end up with a layered ‘double weave’ cloth, or a fabric that doesn’t hold together at all.

Because it has a ‘tie up’, this is a weaving draft for a floor loom with treadles. The same pattern would be possible on a table loom, but with a more fiddly ‘lift plan’ in the place of the treadling on the left – it would look similar but would have multiple lifts per weft to account for the lack of tie-up.

This interface is multi-user, so one person can be adjusting the threading, and another playing with the tie-up or treadling, while another is actually weaving the pattern at the TC/2. In practice this was a lot of fun! Having Kristina weave at speed, seeing a pattern emerge, and then making some adjustments while she was still weaving.. The adjustments would involve intermediary states that would get woven into the fabric, so that there would be glitches in the transitions between one pattern and another.

The TC/2 loom we were weaving on is an interesting loom designed for prototyping – there is a single foot switch for lifting the warp threads so that the next weft is passed, but then the human weaver who actually passes the weft. This means a wide range of yarns can be used for the weft that a machine wouldn’t be able to cope with, and adjustments can be made by hand. As mentioned in my previous blog, Pei and I ‘hacked’ the loom so that what warp threads are lifted can be controlled live by software, using the MQTT protocol.

Part of the fun of all this came from the knowledge that changing the threading on a shaft loom might take hours, perhaps days or even weeks, but using this shaft-loom simulator to control the TC/2 meant it could be changed immediately. In practice working with this kind of weaving draft is highly generative, as Lea Albaugh explains, the binary logic of shaft looms is matrix multiplication; how the different interacting layers and resulting cloth interact is fascinating, taking a life time to explore.

We talked a lot about the relation between live coding with something like Strudel, and weaving, with Helen wanting to apply strudel-like patterning to weaving design. Helen has had a more traditional training in weaving, so well-used to loom-thinking, and seemed to take well to this shaft-loom interface to the TC/2, enjoying the live, physical design process. I’m looking forward to talking more about the possibilities of developing pattern languages for live weaving.

Back home, I was ready to change the threading on my table loom. I’d become interested in crackle weave, enjoying the computer generated crackle weave patterns created by the late computer scientist Ralph Griswold. Frustratingly, his papers refer to his weaving drafts available for free on handweaving.net, but have recently been paywalled, apparently under a restrictive license. Certainly a lot of work goes into this site, but this seems unethical, and it’s unclear on what basis the maintainer of the site is restricting its use. In any case, so far they sadly do not wish to discuss this, but I hope to spend some time on archiving these drafts openly and for posterity on archive.org.

Still, I managed to download a draft, and adjusted it for the number of threads in my current warp, using Laura Devendorf’s fantastic AdaCAD system. AdaCAD also made converting from a floor loom to table loom draft very easy. You can see my workings here if you’re curious!

Re-threading the loom was difficult, and took over a day’s work. The threading for this crackle weave is much more complex than the previous point threading, with a lot of back and forth between heddles, and I made a couple of mistakes, but I managed to fix them in the end. I was also happy that despite the complex threading, due to the rules of crackle that Griswold was following in his draft, I was still able to do the simplest plain weave by switching between alternate shafts.

The pattern looked beautiful in AdaCAD, but with the striped warp, it was difficult to see the pattern. I tried a few things to make it clearer, including using ‘overshot’ technique as seen in the lower section of the above photo. This is where the pattern is woven using a thicker (or in this case doubled-up) weft yarn, interleaved with a plain weave. I realised though that this meant only ‘floats’ where a weft goes over more than one warp thread at a time were fully visible. I switched to weaving the pattern directly, but with a doubled up, bright orange yarn as seen in the top section, and am pretty happy with this so far!

Well this blog ended up much longer than expected, and there’s much more to say about how I worked with the crackle weave pattern – how mistakes became apparent, and how I worked around my poor memory by embodying the logic of the lift plan pattern. I’d better stop here for now, though!

We are running a workshop alongside Paola Torres Núñez del Prado and Julian Rohrhuber on the 31st January at the Epistemic Media Research Group (Institute for Music and Media) in Düsseldorf. This event will be a convergence of two areas of recent research, Andean Khipu knotted string records - knots as records of individual's duty to their society, and the peculiarities of labour accounting in historical Cornish mining.

When speaking of “formalisms”, we mostly think of formulas written in a symbolic text. When speaking of “the necessary formalities”, however, we know that we may not only write, but also act formally.

Formalisation has been practiced in many different media, and many cultural contexts, in the form of specific patterns. They seem to always come into play at particular occasions, where they fulfil some sort of “function of formality”. In ritual, bureaucracy, politeness, in transmission and translation, in prediction and calculation, in recording ownership, obligations and debt.

Considering technologies like the Andean Khipu and accounting politics in Cornish mines let us get involved in the particularity of form and learn how to think in its matter. This exchange may help understand new facets of what it means to “be formal” and question premises of textual formalisation, reappropriating it for nonhegemonic purposes.

Info and (free) registration:
https://wertlos.org/epi/beingformal/

After warping the loom, a bit of simulation and some going backwards and forwards I managed to weave the pattern through once, and then took the still warped loom and everything with me on the train to a workshop in Manchester as a demonstration of a more complicated weave and then left it for a few months. Coming back to it I had a record of where I stopped, but the tablets were in a mess from travel, and I wasn't entirely sure what was going on. This must have been quite a normal situation to weavers, no matter when they lived - but I'm going to go through this process in detail and then explain a bit more why I find this interesting at the end.

My first approach was to try to un-weave to a place I thought was I knew was correct and restart from where I thought I was in the pattern, based on what it looked like compared to the simulation. I also thought I could use the border weave (which is simpler) to try and get locked in to the right place but this didn't really work at all, the problem is you start off again and have to undo the wrong bit, and each time it makes it more difficult to know if you've stopped in the right place.

The next approach I used was to use the yarn colour positions in each tablet to figure out where I was. The idea was that this could provide an absolute position given the 'state' of the tablets. In order to do this I had to read off each tablet and record it on a bit of paper, and I adapted a script I've been working on to generate the instructions for hand weaving to output the tablet state after each step of rotating forwards and backwards. This didn't work either, and I'm not entirely sure why - I ended up searching the whole pattern for candidates measured by distance and found some in places that I knew were wrong with a few cards different. I think this as partly but not entirely due to something that I discovered in the course of this that I suspected previously, that the pattern on the simulation is upside down (it's showing the reverse of the weave, but I guess that's subjective!).

The third attempt was to only un-weave a single step (I'd removed quite a lot of the good pattern by this point) and record direction of tablets I needed to rotate to un-weave to the previous weft. I could then reverse the directions to find what the instruction was that I'd previously followed - I could use the same code I'd used to search for the instruction line that matched in the pattern, and this indeed finally worked, I could reweave the pattern I'd un-woven and continue, the pattern looking like nothing had happened.

So the things this involved:

• Written instructions for each step (as well as the warping of the tablets).
• A simulation to check the pattern visually.
• Taking copious notes on bits of paper when it went wrong.
• Algorithms to visualise and search the states of the tablets and the instructions.

The Hallstatt finds were so important that historians have named their ancient society after it - the 'Hallstatt Culture' which existed from 1200 to 450BC. We don't know what they called themselves, what language they spoke, or really very much about them except these kinds of archaeological finds. They are defined as being on the cusp of being a prehistoric culture (techically I think 'proto-historic') because while written language perhaps existed in the area towards the end of their time, we don't really know if they used it - and if they did, it probably wasn't well spread through their society.

So we have no idea how they recorded these patterns - which are far more complex and lengthy than later tablet weaves made by the Vikings for example - did they have a way to do it verbally, or through songs?

They may have been pre-writing - but they certainly weren't pre-algorithmic. These sets of binary instructions are the definition of an algorithm. For me, in 2025 - unpicking this problem required using tools that weren't available at the time, pencils and paper, let along software and source code. What techniques did they use to manipulate and understand the algorithms they created? As we grapple with the realities and failures of AI and accelerationism, there are a lot of things missing in the way our culture understands its relationship to our algorithms - I wonder what they could teach us.

I'm using this repository to keep track of this work, and I'm hoping to get some of these debugging tools into the tablet weaving language which is running here.

Some years ago, I was happy to contribute to an article “Digital crafts-machine-ship: Creative collaborations with machines” lead by Kristina, together with Laura Devendorf and Ron Wakkary. It shares nicely grounded reflections on makers and their machines as ‘crafts-machine-ship’, and re-reading it was a nice framing for my residency with Kristina.

I spent some time getting used to the loom, trying out some patterns I’d prepared using Laura Devendorf’s AdaCAD software, using a bitfield plugin for it that I’d made. The results were quite nice, but although not as striking as the original 2D binary grid of the bitfield pattern that I used as a weaving pattern. Again, this shows a mismatch between a 2D view of weaving and the resulting three dimensional structure. If you treat a loom as a 2D printer rather than a machine for exploring woven structure, the result can be a bit disappointing.

The protocol for the TC2 loom is not publicly documented, but thankfully, Pei had already spent some time reverse-engineering and understanding the protocol, and it was surprisingly quick to reach the satisfying point where we could talk to the loom from a Python script, and hear the loom’s 1,320 pneumatic heddes lifting. Weaving structure is all about binaries (mainly up/down values) and so it wasn’t a surprise that the protocol was binary as well, although it was a challenge to map to the particular arrangement of heddles across the loom’s six pneumatic modules. Astonishingly, we somehow got it right first time, although couldn’t believe it and spent a long time looking for errors in our mapping.

In search of errors, I thought I’d run a cellular automata on the loom, in particular Wolfram’s rule 30. I imagined myself checking the mapping manually by looking at the threads and running the algorithm in my head. In practice that was too difficult for my tired brain but it was a fun exercise, at least. Errors were a bit of a running theme though, with the various knitting machines breaking down around the lab, sometimes in interesting ways, sometimes just not working. The loom had all the luck.

With the TC2’s protocol in hand though it was straightforward to expose it via the MQTT internet-of-things protocol (using the mosquitto server and the paho client libraries for python and javascript), allowing instructions to be sent straightforwardly and securely with a couple of lines of code. Some fun experiments with ‘liveness’ could begin.

One thing I wanted to try was to influence the weave with the rhythm of the weaver. In the below perhaps you can see a repeat every 128 stitches. Within this repeat, the number of white warps that are lifted (and therefore visible on this side of the textile) depends on the duration of time between successive presses of the loom’s footswitch (which lifts the warps for the next row). The lifted warps are spread out as evenly as possible, according to Bjorklund’s algorithm (made famous in algorithmic music as the method for creating ‘euclidean rhythms‘). You’ll also notice a diagonal pattern – this is a result of the pattern being shifted by one thread each row, in my efforts to avoid ‘floating’ threads.

It was fun trying to weave as metronomically as possible – the more regularity I had passing the weft and pressing the footswitch, the clearer the diagonal ’twill’ lines would become. The loom makes its sounds, as does the passing of the weft shuttle and beating the new row into the weave. At the top of the photo you can see more diagonals appearing than previously (in this kind of weaving, time goes ‘up’) – this is where I actually used a metronome app on my phone to help time my foot presses. However the loom itself intervened, by sometimes adjusting itself to move the fabric forward, so the timing could never be perfect. You can also see horizontal bands in the weave where I had issues with e.g. dropping the ‘shuttle’ or hitting some snags, which took time to resolve.

Again, with Kristina’s encouragement to ‘increase the volume’ I later tried the same experiment with larger units of ‘waffle’. Working with structural elements that exist across 10 rows, but changing the pattern every row, meant that the waffle patterns were corrupted unless I wove regularly. Working with larger structures rather than individual threads, I didn’t need to shift the pattern to avoid ‘floats’, so there are no diagonals here.

Another live experiment involved the Khipu-inspired tangible interfaces made by Dave Griffiths with support of Paola Torres Núñez del Prado. The image shows the khipu-inspired strands hanging down on the loom in a tree structure, representing a weaving pattern. For this I again employed the Bjorklund algorithm mentioned above, with three ‘inputs’ – a) the number of threads to lift, spaced out over b) a number of warps, and finally c) the number of warps to shift the whole pattern by. Each of these inputs could themselves be ‘patterned’ by being given more than one value to cycle around, row-by-row. By giving varying number of values for each input, an interference pattern could be set up, creating long-form patterns.

The result was a little disappointing, again this can happen when you treat weaving as a two-dimensional structure; the results can be less interesting in textile than on screen. But I decided to persevere, and eventually noticed that there was an interesting pattern of floating warp threads emerging. The interference pattern had created a long-form pattern that repeated only a couple of times across the 1320 warp threads. It was difficult to see, but by running my finger across it I could sense a nice rhythm to it.

A nice thing about experimental weaving is that it is self-documenting – every movement of the warp threads is recorded in the textile itself. To some extent I didn’t need to write down what I was doing, as it was all recorded in the textile. I took this a bit further and made a khipu with the same knots and structure as the electronic version, but purely out of yarn. I could then weave this into the textile to record the ‘source code’ of the weave that followed.

There were so many ideas flowing over the two weeks, for example one conversation with Pei was around how the khipu-inspired interface could be used to work to notate a kind of evolutionary algorithm to generate/breed her (incredible) knitted sea slugs.

We also had some fun with Luke Iannini’s excellent ‘recognition kit’ in the realtalk system I’d carried to Eindhoven with me, getting it to talk to the loom, and also thinking about recognising patterns in textiles to use them as language interfaces, as seen below.

Pei and I talked a lot about how to connect up her knitting software to the network, with tantalising possibilities of sharing patterns between knitting and weaving software and machines. These are very different structures (I like to think of knitting, weaving and languages like javascript as being equidistant), so this feels a bit ‘illegal’, but has to be tried! Certainly it would be fun to have interplay between the rhythm of a knitter and a weaver, perhaps the movements of one disrupting the other. The general feeling of flows of patterns moving around the lab, perhaps being transmitted from or replicated in a remote location (such as here in Sheffield) as ‘textile telematics’ seems to have a lot of possibilities. It will be fun to explore recent and historical precedents, such as the use of worksong to keep patterns in living memory, and transmit and synchronise patterns between people.

It was also great to run a couple of strudel live coding workshops while in Eindhoven, both at the University as part of my residency there, and at Baltan Laboratories with the local branch of Netherlands Live Coding Live (nice recap video here). Lots of enthusiasm from the younger generation!

This all really renewed my interest in weaving and textiles in general, and the collaboration with Pei and Kristina feels like it’s just beginning, so fun times ahead! It was also lovely to be resident in such an active lab, with a great ‘demo culture’, prompting a lot of great conversations with the people I met. Big thanks to them for hosting me, also for many of the above photos..

I’ve been deeply inspired by Konnakol while learning its fascinating geometric rhythms, and some of this inspiration has found its way into my performances, via some new functions I’ve added to the Strudel and Tidal live coding environments to better support these structures. I recently presented a paper on the topic at the 12th FARM workshop (FARM being short for the International Workshop on Functional Art, Music, Modeling and Design). Here is the abstract:

Konnakol is a South Indian, Carnatic musical practice involving the vocal recitation of algorithmic, geometric rhythmic patterns of non-lexical syllables. I reflect on the experience of learning konnakol rhythms, and of adapting the TidalCycles and Strudel live coding environments to better represent Konnakol-inspired rhythms, based on the concept of the metrical tactus. I share visualisations of examples, and the development of a hybrid practice that integrates vocal patterns with live coding. I conclude by considering the issue of cultural appropriation around this work.

You can read the full open access paper in the ACM digital library. I’m looking forward to taking this forward in some upcoming collaborations, and will soon share an online interactive resource I’m working on for exploring some Konnakol exercises.