New Tool (2.8): Clip Composing Language

(elmex) #1

Hi all!

I’ve recently been messing around with my clip based composition tools, and
started with a new approach. The Clip Arranger/Composer I programmed about a
year ago was quite complicated, at least the GUI for the composer was quite
complex. ( New Tool (2.8): Clip Arranger (Beta) )

So what I came up with, was to create a sort of programming language for
transforming, positioning, (randomly) selecting the contents of clips. It’s not
thought to arrange the final form of a track, but more as an artistic tool to
initially fill some patterns from the material you already have. Additionally
it allows you to create effect column interpolations and automation curves with
arbitrary mathematical formulars.

So, imagine the ability to define clips like in the Clip Arranger, but instead
of a GUI for configuring follow actions you have a small domain specific
language to define how the clips are placed and mangled, with the ability to
abstract away bigger passages.

The state of the tool: The tool is done, the language is implemented and
tested. Whats not done is the documentation, which still misses a some parts.

Here is the documentation of the language:
Composing Language - Reference

There are some examples and the documentation of the main parts is mostly done.

I hope someone finds this useful, I wrote it mostly for myself to improve my
own workflow.

You can Download it here: http://ue.o—

If you need more examples of CCL code you can look in the test directory. The tests there
cover nearly every aspect of the CCL syntax and most of the semantics:

And here is a short workflow gif demo:

(KMaki) #2

That seems REALLY interesting! Keep pushing it towards a release! :yeah:

(.xrns) #3

Very interesting, this is definitely going in the right direction.


(vV) #4

Scripting inside scripting…
The idea to create a cross compiler for C-sound score files in lua crossed my mind once… But you can’t translate everything in score files to Renoise output (C-sound is pretty versatile).
This approach might work better.

(Cas) #5

I’m a fan
Exactly what I should’ve made for the drum track(s) on my submission to the EatMe compo

Plans on releasing?
I just want to say, awesome work, please know that the Overtune tool… don’t know really if a lot of people use it, but the point is: when I dropped it here at first it was not very ‘userfriendly’ at all but the support on the forums had me go on with it and improve it.

(elmex) #6

Sure! I’ve implemented writing the pattern data and importing/exporting
the clip composing language program texts to/from files. A small
code cleanup, finishing documentation and packaging it needs to be done

(Akiz) #7

Nice idea but do you know about ReNoam? ;)
If i understand You are developing same thing but with different language, right?

(elmex) #8

Yea, I know ReNoam, it’s kind of similar. But CCL is more fine grained. ReNoam
only allows you to define which patterns (identified by numbers as far as i
understand it) to use. CCL allows you to make clips from any number of lines in
your track, it allows you to handle your bassdrum track differently from the
snaredrum track for instance. Where in ReNoam you had to decide what the
contents of the individual tracks of a pattern had to have.

And of course the language is different. CCL is has a more constructive
approach to “build” your composition, you take your clips, and mangle, select,
loop, align and bring them into sequence.

Further plans/ideas I have for CCL, in case it proves useful, are that you
could add transformation operations that allow you to transform your lines on
the fly. eg. transpose the melody, apply some random grove/pattern in the
delay track, or create automation/fx ramps.
But I worry that those transformations are not that useful to the creative
process, because if you want to actually edit your notes/fx/events then you
should use the proper tool for that, and that would be the Renoise
pattern editor and not some weird programming language :) So I focus on a more
basic and simple language for now.

(elmex) #9

Just FYI, I updated the documentation, it covers all constructs now:
Clip Composing Language Readme

(KMaki) #10

I would be really interested to see how you built the tool. I had a go at parser building with lua myself, but being a complete novice, it quickly got out of hand. Didn’t really know how those are programmed… So eagerly waiting to have a peek!

(elmex) #11

Oh, of course. Here is my mercurial hg repository. Have a look:

It’s a simple recursive descent parser, which uses closures and a helper class to hold state to build the
execution tree. It’s not really a parser “by the book”, but it works and is reasonably short. My experience
in writing parsers and language implementations and my major subject (compiler construction) in my studies
helped a lot getting it down and working so quickly.

(danoise) #12

Next level stuff. Seems very well organized.

Are you already using CCL yourself?

(elmex) #13

Hehe, the idea and implementation came pretty quick. I didn’t
have enough time to actually work with it on a ‘real’ track.
Of course it was tested with some test content :)

(elmex) #14

Just FYI, I’ve updated the documentation a bit, with all the new stuff that came to my mind and which I implemented:

(As you can see from the repository history, I’ve been working on it constantly.)

(elmex) #15

Updated the first post and added the release, even though the documentation is not completely finished.
Maybe someone already has some fun with it.


Wow… this is very impressive, it goes deep :)

I’m just scratching the surface and making polyrythmic beats with it, it’s so good! Is it is possible to make clips out of multiple tracks or tracks in a group?

(elmex) #17

Group tracks! Good idea, I made clip() aware of track groups in version 1.06 (you may update
anytime). That means you can now make a clip in a group track, and when using clip() it will return
a collection which will also contain the contents of the group members.

You can read about that here:

Oh, and btw. if you need more CCL examples, you can browse the test directory:

(Djeroek) #18

Very cool! Going through the reference right now, algorithmic composition in Renoise ftw!

(elmex) #19

I’ve updated the tool again, to version 1.07.
Changelog can be found at http://ue.o—
Also extended the documentation about user defined sources & operations: http://ue.o—

(elmex) #20

Btw. with the now released version 1.08 you can access and transform the pattern editor selection directly using selection() and “Save & Exec Selection”. This allows you to implement your own “advanced edit” operations.