It is based on Tyler’s script, which also streams to justin.tv.

This is a transcription of this video from Revision 2012.

Requirements for a 64k synth

• small
• flexible
• somewhat usable

The Idea: Runtime Code Generation

• Theory
  • Write synths & effects, bear changes instantly
  • JIT compiler in editor, store compiled data in intro
  • your synth is no longer limited to your own dsp routines
  • host language independently (?)

• Implementation Challenges

  • How to implement this in my synth?
  • How to make this usable for non-coders?
  • Instansing
  • When writing runtime code, you want to contentrate on the good parts

• Implementation: Compiler (bero)

  • designed a language (aulan)
  • supports integer, boolean, float, arrays, structs, functions, procedures, pointers, inline asm
    • translates to assmebler/native code
  • special feature: instance variables
  • language features:
    • mixture of basic, pascal and c
    • newline = end of block statement
  • compile to native code and links during runtime (Editor)
  • in your intro:
    • use generated assembly files
    • use bero’s runtime linker code for object files as constant byte arrays etc.
    • use your normal linker if it supports COFF

Lets take a look at synth design

• a (64k) synth has multiple layers
  • Voice layer
    • code that gets executed per active note
    • classic synth: fixed pipeline
    • most timecritical code
  • Channel Layer
    • code that processes the sum of all active notes of a single instrument
  • Global Layer
    • code that processes the output multiple instruments
    • e.g. sendto-effects, mastering chain
    • example: Buzz – generator & effect concept

Fixed Pipeline vs Dynamic Pipeline

• Fixed Pipeline
  • A good fixed pipeline can be very versatile
  • It’s small
  • Drawback: you need a good fixed pipeline (ask your musician
  • global hardcoded effect-chain / sendto-effects
• Dynamic pipeline
  • not all “modular” synths provide modularity on each level (like Buzz)
  • if done on voice level:
    • allows more complex synth patches
    • more implementation
      • the more granular, the more complex
  • GUIs for modular synths either require a bit of work or they are slightly challenging to use
  • custom mastering/effect chain for free
• Hybrid / Semi-Dynamic pipeline
  • Some parts static, some parts dynamic

Parameter Automation / Envelopes

• WOBWOBWOBWOBWOBWOBWOBWOBWOBWOBWOBWOB
• very important to make instruments sound “alive”
• Different approaches:
  • Modulation matrix (fixed pipeline)
  • modular: e.g. node based, operator stacking
  • LFO with fixed targets as volume, filter, pitch
• if you implement this wrong:
  • bad performance

The Synth

• What is it?
  • Concept blatantly stolen from buzz
  • You create machines, write code for thm
  • machines can be assigned to a midi channel
  • variables can be exported as parameters
  • parameters can be bound to midi-controllers

It was made using SDL, so it should be cross platform. And it features sine, sawtooth waveforms, ADSR envelope, instrument saving, state variable filter and lots of hacks. It also has an oscilloscope-kind of graph, to display how the final sound wave looks like. I will post more details later, because I could not find any good tutorials on how to make my own synth.

vs

SanDisk 16GB: 4.6 MB/s write.
SanDisk 16GB: 18.5 MB/s read

Transcend JetFlash 500 16GB: 18.4 MB/s write
Transcend JetFlash 500 10GB: 34.1 MB/s read

As we can see the Transcend USB stick is 4 times faster writing, and 1.8 times faster reading than the SanDisk Cruzer.

The memory sticks were tested using the dd tool, and the cache was cleared between each run by unmouting and removing the memory sticks.

• First step is to set up key-based passwordless login.
• Install gkrellmd (gkrellm-server). As I use debian I type “apt-get install gkrellmd”. Use your flavor of package-manager.
• (optional) Edit /etc/gkrellmd.conf if there’s anything you’d like to change. The default works perfectly when using SSH-tunnels, because it looks like you’re running from localhost. If you don’t want to run over SSH you could add your desktop’s IP in allowed-host. Restart gkrellmd if you have changed the config.
• Now open a SSH-tunnel on your desktop to your server. The text in red you should change to your wish, and the text in green is OK if you didn’t change anything in the config-file.
• ssh -N -f -L 19150:127.0.0.1:19150 user@server
• The red number is the local port which leads to your tunnel. If you want to monitor more than one computer you’ll need to change this number to an available port (check with netstat -nt). The red text is of course your user login on the server.
• run:
• gkrellm -s 127.0.0.1 -P 19150
• The red number should be the same as above.
• GKrellM should pop up and do it’s thing

I’ve just finished the new game Portal, from Valve. It’s pretty much about making Portals, and using them to solve puzzles. But the portals are a really spectacular method of doing stuff. You can do pretty much everything with just placing 2 portals somewhere, and walking/jumping into them. If you’d like a short preview, watch this video.

You start of at simple training, where you walk trough a portal, and simply picking up objects. Then you advance step by step, learning how to do things. Later you are tested in these skills, and you have to find your way to the goal. The problems get more and more complex, but not so hard if you just use a few minutes to think first. The game is over too quickly tho, but I think that’s better than dragging the story even further. Now people will want more, and try the bonus challenges, and probably the sequel (of some kind) that they talk about in the commentary. There are some extra material to do after the story, like challenges, advanced tests, achievements and commentary from the makers.

One of the fun parts about the game is the story, and the computer that communicates with you while you play. Her name is GLaDOS, and has a very dark humor that probably will make you laugh. I recommend turning on the subtitles, as it’s sometimes hard to hear what she’s saying.

So… I really recommend this game. It’ll make you laugh, think and have fun. I really did!