Bowntz is a little world of colliding circles, implemented in Haskell using OpenGL for video and SuperCollider3 for audio. Its simulation algorithm is based on directly calculating the time until the next collision rather than stepping through time at a constant rate.

Bowntz source code repository at Gitorious

git clone git://gitorious.org/bowntz/bowntz.git

Bowntz (demo 1) video

Konstrukt is an SVG + ECMAScript application for compass and straightedge construction. It's not too unintuitive to use, once you know what the controls are:

to draw a straight line through two marked points

press the v key and click on the two points

to draw a circle centered at one marked point through another

press the c key and click on the two points (the first of which is the center)

to delete a marked point and all edges through it

press the x key and click on the point (tip: you might create extra lines and circles for the purposes of deleting at an intersection)

to move the viewpoint

click on empty space to center the view on that position

to zoom in

press the PgUp key

to zoom out

press the PgDn key

New in Konstrukt version 2 are some more attractive drawing tools that are locked to the construction points, useful perhaps for mathematical diagrams like the above 3 octahedra around a line in a 24-cell:

to draw a line segment between two marked points

press the s key and click on the two end points

to change the line segment thickness

press the - key or the + key

to draw a filled polygon

press the f key and click on as many points as you like, then press the z key

to change the fill colour for future polygons

press the [ key or the ] key

I'm playing tonight at Goldsmiths Digital Studio Expo.

Cut and paste info follows:

FREE ENTRY - OPEN DAY // Ben Pimlott Building, Goldsmiths, University of London, New Cross SE14 6NW

LIVE PERFORMANCES FROM 6:30pm // programmed by TOPLAP and noise=noise // livecoding - diy punk electronics - corrosive sound - hyperspace techno

• John Wall
• Dave Griffiths
• ClaudiusMaximus
• Jamie Forth
• Renderplant
• Sick Lincoln
• Alex McLean
• Hylics

There's also an exhibition running from 2pm.

buildtorrent is a simple command-line .torrent file creation tool.

buildtorrent 0.8 (2010-01-31) comfy chair

Changes since buildtorrent 0.7 (2008-04-13):

Fixed bugs:

• announce-list segfault on 64bit

New features:

• webseed url-list (-w)
• piece length as a power of 2 (-L)
• torrent name (-n)
• external file list (-f)

New homepage:

• http://claudiusmaximus.goto10.org/cm/torrent.html

New repository:

• http://gitorious.org/buildtorrent

The transition from 0.7 to 0.8 involved some extensive code reorganisation to make it possible to add the new features: as with any such extensive change, this may have introduced new bugs. If you find a bug, please report it.

Download the release tarball: buildtorrent-0.8.tar.gz

Checksums:

3bba072cc89d2b8b4198c85734e39302 *buildtorrent-0.8.tar.gz
32694478ddef91453dc85ab7a2e659132adadeb6 *buildtorrent-0.8.tar.gz

Manual page:

Synopsis

buildtorrent [OPTIONS] -a announceurl input output

buildtorrent [OPTIONS] -a announceurl -f filelist -n name output

Description

buildtorrent is a torrent file creation program. Given an announce url and an input file or directory, buildtorrent generates an output .torrent file that can be used by torrent clients.

Options

-a announce, --announce=url

Announce URL (required).

-f filelist, --filelist=filelist

A text file (or - for standard input) containing a list of files to add to the output torrent file, together with the path to use inside the torrent. One file is given per line, use / as path separator for the torrent path, use | to separate the filesystem path from the torrent path. Backslash \ can be used to escape newlines and | characters inside names. For example:

/data/files/linux.iso|bin/linux.iso
/data/files/linux.txt|doc/linux.txt

Using this option requires that the --name option be used.

-n name, --name=name

Specify the name for the torrent. Usage of this option is required when the --filelist option is used, in which case it specifies the name of the torrent directory. Usage without a file list overrides the name of the directory or file given on the command line.

-A announces, --announcelist=announces

Additional announce URL list. Use , to separate outer level lists, and | to separate inner level items; for example:

a,b1|b2,c

-w webseeds, --webseeds=webseeds

Additional WebSeed URL list. Use , to separate items; for example:

a,b,c

-l length, --piecelength=length

Piece length in bytes (default 262144).

-L size, --piecesize=size

Use 2^size as piece length in bytes (default 18) (overrides -l).

-c comment, --comment=comment

User comment (omitted by default).

-p private, --private=private

Private flag (either 0 or 1).

-D, --nodate

Omit the creation date field.

-C, --nocreator

Omit the created by field.

-m, --md5sum

Add an md5sum field for each file.

-s, --show

Show generated torrent structure.

-S, --showall

Show generated torrent structure, including piece data.

-q, --quiet

Quiet operation with reduced output.

-V, --version

Show the version string.

-h, --help

Show a help screen with brief usage information.

See also

• createtorrent
• mktorrent
• http://wiki.theory.org/BitTorrentSpecification
• http://bittorrent.org/beps/bep_0012.html
• http://www.getright.com/seedtorrent.html

Feature comparison matrix:

buildtorrent is more flexible, especially with the external file list feature, but mktorrent's threaded hashing wins if you want to exploit multi-core CPUs.

Some work in progress demos of an audio-visual performance under development. MarkIII is named after the 3rd-order Markov chains it uses to generate sequences of sounds.

Demo 1 is the first proof of concept - sequences of harmonics of a simple tone.

Demo 2 extendes this to sequences of rhythms as well as harmonics of more complex tones.

Demo 3 returns to simple harmonics, but adds visualisation of the Markov Chains in 3D Euclidean space.

Demo 4 is a live recording of the same setup, filmed with a digital camera.

Demo 5 adds more complex organ-based sound, while also changing the visualisation to follow one point in rotations of a 3-sphere in 4D space.

Demo 6 follows two points in a minor scale in this 3-sphere.

Demo 7 improves the rotation algorithm but still suffers from gimbal lock.

Demo 8 adds additional voices and further rotation and colour tweaks.

Demo 9 has a completely new and improved rotation algorithm, however it still rotates the "long way" sometimes and some numerical instability at times.

MarkIII Demos were made with Pure-data using the PdLua, Gem and Zexy libraries.

The source code is available under GNU GPL3+ license, but is still changing rapidly and is unfinished and undocumented:

svn co https://code.goto10.org/svn/maximus/2010/markiii

Downloads:

More download options available at the MarkIII Demos Internet Archive page.

brain massage generative music video // fractal video made with Fl4m6e // organic audio made with Pure-data using GridFlow and Zexy

Downloads:

• DVD (287MB)
• Ogg (24MB)
• MPEG4 (21MB)

FAuSt has a nifty n-ary block diagram parallel composition operator, in which you give it a count and a function from numbers to block diagrams. Something with the same meaning as:

parallel n f = foldr1 Par (map f [0..(n-1)])

If only life were so simple: that won't compile, because of my decision in Heist to express the type system of block diagram algebra within Haskell's type system. So after about 4 hours of head scratching, I finally figured out how to generalize from this:

par0 f = empty
par1 f = par0 f `Par` f 0
par2 f = par1 f `Par` f 1
par3 f = par2 f `Par` f 2
par4 f = par3 f `Par` f 3
...

to the point where this compiles successfully:

import Types.Data.Num.Decimal (d2, d4)
import Heist (Bd (Seq), parallel, add)
import Dot (toDot)

main = putStrLn(toDot(

    parallel d4 (const add) `Seq`
    parallel d2 (const add) `Seq`
    add

  ))

Check out the code to see the horrible gory details, where at the time of writing (Subversion revision 1582) the relevant excerpt is lines 222-256 of Heist.hs:

svn co https://code.goto10.org/svn/maximus/2009/heist heist

At this point I was happy and delighted, but not for long. I tried to compile a program containing parallel d8 add and waited, and waited, only to find (7.5 minutes later...) that GHC reached my operating system's limit of 3GB per process and gave up. It was a similar story when explicitly limiting the heap size. I ran some tests and it seemed that the compilation time grew exponentially with the parallel count.

The "shortcut" of embedding FAuSt semantics inside Haskell to avoid having to write a parser and type checker and all the rest turned out to be a rather more "scenic route" through type level programming, but in summary: theoretically beautiful, epic fail in practice.

So I was playing around with FAuSt, a pure functional dataflow language for audio stream processing. At first I thought it was great, but then the compiler bugs bit hard: declaring two variables with the same name in the same scope made the compiler segfault [2010-01-13 update: I have not been able to reproduce this crash, so I'm probably wrong about the cause], and for some reason it thought the index variables in my parallel constructs were duplicates too. I was trying to build a 16x16 matrix multiplication to implement my favourite reverb... perhaps too ambitious? Simple things are very concise in FAuSt, though: I implemented Pure-data's vcf~ in roughly the same number of characters as the number of lines of code that the C implementation had:

vcf(q,f,x) = w ~ (_,_) with {
  a = max(f * 2 * PI / SR, 0);
  r = max(1 - a / q, 0);
  c = r * cos(a);
  s = r * sin(a);
  k = (2 - 2 / (q + 2)) * (1 - r);
  w(u,v) = (k * x + c * u - s * v) , (s * u + c * v);
};

So I thought to myself, with Haskell's awesomeness I should be able to embed the core of the FAuSt block diagram algebra semantics in a typesafe way. Much headsploding followed, figuring out how to bluff my way through type-level programming, until I managed to express the preconditions and results of each of the five block diagram composition operators.

It might help to know what a block diagram is and how they can be composed. For that I recommend Chapter 3 of A FAuSt Tutorial (PDF). I decided that GADTs were what I needed, with constructors for each of the composition operators, and one for primitives:

-- abstract block diagrams
data Bd t where
  Rec   :: (...) => Bd i -> Bd j -> Bd k
  Par   :: (...) => Bd i -> Bd j -> Bd k
  Seq   :: (...) => Bd i -> Bd j -> Bd k
  Split :: (...) => Bd i -> Bd j -> Bd k
  Merge :: (...) => Bd i -> Bd j -> Bd k
  Prim  :: (...) => String  -> k -> Bd k

I've omitted the contexts here, because they are quite long, expressing the necessary preconditions on the shapes of the block diagram inputs and the resulting output block diagram shape. I'm using "shape" to mean a pair of type-level lists, for example a standard (+) :: Float -> Float -> Float operator lifted to a block diagram could have a shape like (Float :. Float :. Nil, Float :. Nil), depending on how spicy you like your curry.

FAuSt semantics for the recursive composition operator A~B are described informally like this (where (i|o)X is the number of inputs|outputs of X):

• the first iB outputs of A are fed into the inputs of B
• the outputs of B are fed into the first oB inputs of A
• the remaining iA-oB inputs of A are the inputs of A~B
• the oA outputs of A are the outputs of A~B

From this description it's easy to see the requirement that oA>=iB and iA>=oB, moreover the types of the inputs must match the types of the outputs they are connected to. This precondition on the compatibility of the shapes, and the shape of their composition, can be expressed like this:

-- recursive composition compatibility and result shape
type family IsRecCompat x y
type instance IsRecCompat (xi, xo) (yi, yo) = (Take (Length yi) xo `Equals` yi) :&&: (Take (Length yo) xi `Equals` yo)
type family RecShape x y
type instance RecShape (xi, xo) (yi, yo) = (Drop (Length yo) xi, xo)

Here Take, Drop, Length, and Equals operate on type-level lists. The full type of the Rec constructor is now:

  -- recursive composition constructor
  Rec   :: (NaturalT (Length ai), NaturalT (Length ao),
            NaturalT (Length bi), NaturalT (Length bo),
            NaturalT (Length ci), NaturalT (Length co),
            i ~ (ai,ao), j ~ (bi,bo), k ~ (ci,co),
            IsRecCompat   i j ~ True, RecShape   i j ~ k)
        => Bd i -> Bd j -> Bd k

where the first 4 lines express that the lengths of the lists are non-negative numbers and that the shapes are pairs of lists - not sure how to simplify this boilerplate which is present for all the operators, but it seems to work ok.

With the fixities as in FAuSt...

infixl 4 `Rec`
infixl 3 `Par`
infixl 2 `Seq`
infixl 1 `Split`
infixl 1 `Merge`

...and suitable definitions of primitives, it's possible to write expressions that look like a more verbose FAuSt, and manipulate them in various ways:

-- example
main = putStrLn (toDot(
  castF `Par` castF
  `Split`
  ( addF `Par` subF `Par` mulF
     `Split`
     (addF `Par` addF `Par` subF `Par` divF `Par` negF)
  ) `Par` addF
  `Merge`
  addF `Par` castI
  ))

I won't talk about the toDot code right now, as it's not too impressive compared to the rest of the code - but if you want to look the whole lot is in my messy Subversion repository:

svn co https://code.goto10.org/svn/maximus/2009/heist heist

And why the name Heist? Maybe I'm trying to steal FAuSt's thunder! Or it could just be that it's got an H and an S in it...

A long while ago I documented how I went about encoding videos. I have since found a much better way to do this, adapt as you see fit for fps and bitrates, and it's possible to do it without intermediate image files - handy when you're experimenting with high definition video.

ppmtoy4m -S 444 -F 50:1 < "video.ppm" |
ffmpeg2theora -f y4m -V 1000 -o "video.ogg" -

oggenc -b 192 -o "audio.ogg" "audio.wav"

oggz-merge -o "final.ogg" "video.ogg" "audio.ogg"

If you do have image files already, ffmpeg can convert them to a yuv4mpeg stream.

ffmpeg -f image2 -i "img%05d.tif" -pix_fmt yuv444p -f yuv4mpegpipe - |
y4mscaler -I sar=1/1 -O preset=dvd |
mpeg2enc -f 8 -q 2 -o "video.m2v"

y4mscaler-9.0 doesn't compile out of the box with the latest mjpegtools libraries, here's the fix (at least for libmjpegtools-dev version 1:1.9.0-0.5ubuntu1):

--- y4mscaler.C.orig    2009-10-28 00:32:21.000000000 +0000
+++ y4mscaler.C 2009-10-28 00:33:51.000000000 +0000
@@ -194,7 +194,7 @@
   if (source.read_stream_header(fd_in) != Y4M_OK)
     mjpeg_error_exit1("Failed to read YUV4MPEG2 header!");
   mjpeg_info("Input Stream Header:");
-  source.stream().log_info(LOG_INFO, "<<< ");
+  source.stream().log_info(mjpeg_loglev_t("info"), "<<< ");
 
   /* set target stream defaults from source stream */
   target.init_stream(source);
@@ -216,7 +216,7 @@
   /* set up target stream */
   target.stream().write_stream_header(fd_out);
   mjpeg_info("Output Stream Header:");
-  target.stream().log_info(LOG_INFO, ">>> ");
+  target.stream().log_info(mjpeg_loglev_t("info"), ">>> ");
 
   /* do some scaling */
   scaling.create_scalers(source, target);

And just another little tip: Dirac encoding is still awesomely slow, so I'm sticking with Theora (or MPEG2 for DVD) for now.

Live improv techno performance on 2009-11-13 at Kiblix, Maribor, Slovenia, using Pd, Gem, GridFlow, etc.

Downloads of the digital render:

• DVD (1.5GB)
• Ogg (154MB)
• MPEG4 (139MB)

buildtorrent used to have its own page, but that part of this website has been dismantled, so here is the content that was previously available:

Synopsis

buildtorrent [OPTIONS] -a announceurl input output

Description

buildtorrent is a torrent file creation program. Given an announce url and an input file or directory, buildtorrent generates an output .torrent file that can be used by torrent clients.

Options

-a announce, --announce=url

Announce URL (required).

-A announces, --announcelist=announces

Additional announce URL list.

-l length, --piecelength=length

Piece length in bytes (default 262144).

-c comment, --comment=comment

User comment (omitted by default).

-p private, --private=private

Private flag (either 0 or 1).

-D, --nodate

Omit the creation date field.

-C, --nocreator

Omit the created by field.

-m, --md5sum

Add an md5sum field for each file.

-s, --show

Show generated torrent structure.

-S, --showall

Show generated torrent structure, including piece data.

-q, --quiet

Quiet operation with reduced output.

-V, --version

Show the version string.

-h, --help

Show a help screen with brief usage information.

See also

• http://wiki.theory.org/BitTorrentSpecification

The above is the manual page from the buildtorrent-0.7.2 source tarball, double-check your local buildtorrent package for the manual corresponding to the version you have.

Some new news now: progress on the 0.8 release of buildtorrent is very slow, as I have too many other things I prefer to spend my time on. The roadmap is roughly:

0.8

implement the already-documented file list feature

0.9

fix all remaining bugs

1.0

final release

2.0

go crazy with all kinds of freaky features

Hopefully 1.0 will get finished by the end of the decade. Jan Stępień sent me (a couple of months ago...) a patch for multi-threaded hashing, but I didn't have a multi-core machine at the time - expect that as an optional configure-time switch in Subversion as soon as I've had time to test it.

The freaky features I have in mind for 2.0 include distributed .torrent creation within a trusted swarm for later publication to an untrusted swarm. It should allow torrents to be created when not all the files are local without transferring large amounts of data.

You can get the development version of buildtorrent here:

svn co https://code.goto10.org/svn/maximus/buildtorrent buildtorrent

rdex has a new website, all shiny and new in preparation for the Kiblix festival in Maribor, Slovenia this week. The rdex gallery installation will feature a physical space map of the parameter space hitherto only represented virtually, and runs from this Thursday 12th through to Saturday 14th November 2009, with the online portion remaining afterwards as an artifact of the process.

I'll also be performing improvised techno with hyperspace visuals on the Friday, see the Kibla website for full schedules and more info - it's a packed week with workshops too.