Category Archives: Uncategorized

TWO 0.9.10 Released!

This release contains an important, major set of changes which together makes the use of TWO with other OSC-enabled applications much smoother.

The features come out of extensive testing with many other applications, such as MadMapper, OSC/Pilot, Resolume, VDMX, among others.

Currently it is released for Windows, with OS X coming up.

Messaging logic overhaul throughout

Current / Offset distinction

Current / Offset distinction is introduced for all Addresses more explicitly. The previous, more imprecise “In/Out” naming is removed.

Direct Mode

Introduced “Direct Mode”, which when enabled, uses only “Current” value, without offset, and which echoes the values back to destination, resembling how most other OSC applications work. When Direct is on, Offset is not used.

Direct mode is similar to all other OSC controller/timelines software, e.g. TouchOSC, Lemur, OSC/Pilot, Vezer, etc, and makes for straightforward use, but precludes from setting up the complex OSC mappings that TWO makes possible. But now in TWO you have a choice of both immediacy and rich mappings, selectively using Direct mode for those devices that warrant it.

“Echo Default” feature

Introduced option for distinguishing if values are defaults or not, and choosing whether those are echoed or muted, when an echo operation is triggered.

By default it is on.

OSQ Query

  • Support fuller set of OSQ Query specification, tested with MadMapper
  • Better OSC Query integration with TWO
  • Also listening for changes from the OSC Query servers that support this.
  • Explicit connection / disconnection

Feedback detection

Added Feedback Detection for OSC messages throughout. When feedback is detected, the message in question is muted. If you want you can turn this off – by default it is on.

Finally, in this release I’ve fixed several smaller bugs and crashes.

New TWO Release! (

I’ve just uploaded a new release of TWO,, for Windows and OS X!

OSC Query

Most important addition is a first implementation of OSC Query support, tested with MadMapper on Windows.

I find OSC Query to be a very exciting technology and am keen to expanding the functionality. The interaction with other applications it makes possible is very powerful!

TWO and MadMapper getting along!

Future updates will be tested with more OSC Query applications, on OS X and Windows.

Moreover I’ve created a new Discourse based forum! Please head to to discuss TWO, using OSC, OSC Query, or anything else you feel is relevant.

Finally, the release comes with several bug-fixes and performance optimizations, edging closer to a 1.0 release.


On Windows:

TWO is now 64bit, meaning you may have to uninstall your previous 32bit build separately from installing this new version.

On OS X:

The update may fail depending on your OS version, due to the installer not being Apple-signed. In that case download it from here and follow the instructions on that page.

TWO & Resolume Integration

I’ve been experimenting with using TWO as a timeline OSC record/edit/playback tool for Resolume, and have come quite a long way, but I’ve realized that by default, Resolume does not react well to having all the data it transmits being sent back from TWO verbatim.

Some messages are not meant to be received at the density they are sent. Others overlap, and while all are sent, only one should be received, etc.

I would love it if you wanted to test things out, to figure out what of the Resolume data should be filtered out in TWO and/or Resolume, so that they can work in unison!

I’ve put together a little video for this post, which you may find a good intro:

What you’ll be able to do with Resolume & TWO

  • Remote-control Resolume.
  • Save states for Resolume, and interpolate between saved states.
  • Sequence these state changes on a timeline.
  • Record all the OSC data that Resolume transmits, thus capturing a performance.
  • Editing and playing back that performance.
  • Sequencing changes of parameters in detail in TWO’s timeline. In interaction with the recorded performance data.

A combined set of features which are very timely with the video recording feature just introduced in Resolume!

Recording and playing back a performance with Resolume and TWO

Resolume has a rich OSC implementation, with the characteristic that it transmits all state, with the same namespaces that it reacts to. This is useful in combination with the automatic namespace building of TWO.

The below steps are as far as I have come, but are not a complete tutorial on making the TWO & Resolume integration work – for that I need your tips on what Resolume likes and doesn’t like to receive!

I’ve made the .TWO file created following those steps, available to download here (unzip and open in TWO).

Of course as we learn the steps below will be updated to reflect the best way to go. Once the integration is finished, I’ll upload a finalized file and make a nice tutorial to go with it.


In Resolume :

  1. In ->Preferences->OSC, ensure OSC Input and Output are both enabled.


  1. Create an OSC Network Location, setting the ports and IP’s to match the ones Resolume transmits to and from. Name it “Resolume”.
  2. In TWO’s Global Settings View, ensure the option ‘Global – Build Namespaces’ Is enabled.
  3. Already, you can record and edit the resolume data, just as in the oscHook example video. As you go, the namespace will be updated to reflect the data received.
  4. But, unlike oscHook, Resolume has a huge, complex namespace.
  5. To instead achieve detailed control, and do extensive editing of a Resolume performance, you need to split the huge global Resolume namespace, into sub-namespaces, each corresponding to a sub-section of Resolume.
One HUGE Resolume OSC Namespace

Above you see TWO with one huge OSC Namespace for Resolume. Below, the alternative, of separating the above to many dedicated sub-namespaces, used in an “Address” hierarchy in TWO.

Separate Namespaces…
…Used in separate “Addresses”.
  1. Load the composition in Resolume anew – this causes it to broadcast all of its OSC namespace.

The Namespace hierarchy appearing is as follows:

  • /composition
  • /composition/columns
  • /composition/columns/n (1 – 9)
  • /composition/columns/n/<>
  • /composition/layers
  • /composition/layers/n (1 – 3)
  • /composition/layers/n/clips
  • /composition/layers/n/clips/n (1-9)
  • /composition/layers/n/clips/n/<>
  • /composition/layers/n/video
  • /composition/selectedclip
  • /composition/selectedlayer
  • /master/<>
  • Etc.

There are at least 3 sub-classes of namespace for Resolume: For columns, Layers, and within those, Clips.

It is straight-forward to adapt to this hierarchy in TWO:

  1. In the Namespaces view, expand the Resolume_auto namespace to show /composition/columns/1.
  2. (You can if you like rename “Resolume_auto” to just “Resolume”).
  3. Right click the Node with pattern “/composition/columns/1”, and select “cut”.
  4. Collapse the “Resolume” tree.
  5. Right-click on the empty area in the Namespaces pane, and select “Paste”.
  6. Select the newly created Root Node, and rename it from “1” to “Column”.
  7. Ensure that in the Property Panel of if, the option “Build Namespace Automatically” is on.
  8. Delete the Node hierarchy /composition/columns within “Resolume”.
  9. Repeat the above steps for “/composition/layers/1”, naming the resulting namespace “Layer”, and deleting “composition/layers” within “Resolume”.
  10. From within the “Layer” you just created, repeat the process for “/clips/1”, creating “Clip”, and deleting the “clips” hierarchy under “Layer”.
  11. Now, switch to the Scene view, and create a hierarchy of sub-addresser under the “Resolume” Address, as below:
  • Resolume
    • Composition
      • Layers
        • Layer1
          • Clips
            • Clip1- Clip9
            • Temp
      • Columns
        • Column1 – Column9
      • SelectedClip
      • SelectedLayer

Address Resolume should have Namespace Resolume. Layer1 and selectedLayer should have Namespace Layer. Clip1 through Clip9, and selectedClip, should have Namespace Clip. Column1 through Column9, namespace Column. Composition, Layers, Clips, Columns, should all not have a Namespace assigned at all, they only serve for grouping.

  • Right click on Layer1, select copy, then right click on Layers, and select paste. Repeat for the rest.

You now have a complete hierarchy you can reuse!

In TWO’s Live view, create a new Global Editor controller – you will see a column with controls for each Resolume sub-address, giving you a neat overview of all OSC parameters.

Depending on how you’ve set up Resolume’s OSC transmission, and how you intend to use it, you may wish to make these additional settings:

  1. Mute input and output on selectedClip, and selectedLayer – since they duplicate what happens in the respective clips and layers in the hierarchy.
  2. Potentially, also mute “/position” in namespace Layer, and “/transport/position” in Clip. Depending on how you use TWO with Resolume, you may or may not want these to be recorded/transmitted.

And, if at any time Resolume transmits a message which is not yet part of any namespace, TWO will automatically create a node for it in the most appropriate namespace from the ones you created, so no message is ever lost.

Save this file, as it will be your starting point for any new project you do with Resolume: this setup needs to be done only once, and given a completed file, you can just download it and use it without going through the above effort every time.

Finally, to add timelines for recording:

In TWO’s Timeline view, click “Create”, and in the appearing pop-up, select “Resolume”, and then click the “Recursive” button. That will add lanes for all addresses. You will see lanes created for all Addresses which have a Namespace assigned, ready to arm, and record clips into, separately!

If you do not want all, you can just add lanes separately for each Address tree separately – for example only the Layers hierarchy.

Recording into separate Address lanes, and editing the recorded data.

That is all for now, I hope you find this promising, and look forward to when Resolume and TWO integrate well together!

TWO Alpha 0.9.4, with Timelines, available for Windows and soon OSX

After extensive development, the new Timelines feature is available to test on Windows, and soon OSX.

In the video above, I showcase one use case, using the AudioVisualBach example program which is included in the TWO download.

The changes to TWO since the previous version are very extensive, besides Timelines, this version also includes a great amount of bugfixes and improvements.

So do go ahead, click on “Downloads” above, and give it a try!

The Wizard of OSC Second Alpha Release – 0.9.3

Model Definition and Editing View

Since the first Alpha release, I have been very busy adding features and fixing bugs, making this version 0.9.3 a much more mature build!

The changes are very extensive, but here’s a summary of the most important improvements made:

•    An entirely new Timeline Sequencer, for arranging saved states over time, and sequencing the gradual interpolation between them.

For now this sequencer has a single lane for states. In upcoming releases, Record, Playback and Re-Arranging functionality will be integrated into additional sequencer lanes (these are the lanes seen at the bottom of the image below).

Timeline view Zoom In
Cut/Copy/Paste/Duplicate implemented for all elements where this makes sense.

•    Many improvements to the GUI. New Icons, and several usability improvements.

•    Extensive bug-fixes throughout. Most importantly:
–    Global settings are now correctly stored and recalled on Windows 8 & 10.
–    Several bug-fixes and improvements were made to Recorder.
–    The rare occasional crashing should now have been fully fixed.
–    The Envelope controller now works correctly across operating systems.

Existing installs can be updated using the “File->Check for Updates…” menu item.

Please keep the bug-reports and feature requests coming, and in the meanwhile I will concentrate efforts to finish the development of the timeline sequencer features, which upon completion will mark the 1.0 version of TWO.

For as long as it is in Alpha, TWO will be free to use. I hope that you find it to be a compelling tool!

In return, please share your bug reports, feedback and suggestions, on the TWO forum:

First Alpha Release – 0.9.2 – download comes with the AudioVisualBach example

Finally, after years in development, The Wizard of OSC (TWO) is ready for a first public Alpha release! Version 0.9.2 Alpha is coming up, for Windows and OS X.

TWO provides a set of tools which together allow the recording, replaying, and creative manipulation of digital media control signals (currently MIDI & Open Sound Control), be it for live sound, graphics, show control, or the Internet of Things. Its functionality is inspired by how live electronic musicians perform using a mixing desk and effects.

Along with the Alpha, I have also created a small independent program that serves as a self-sufficient example of TWO in use, accompanied with a video explanation, as well as a manual explaining TWO’s purpose and features.

For as long as it is in Alpha, TWO will be free to try and use. I hope that you find it to be a compelling tool!

In return, I hope you share your bug reports, feedback and suggestions, on the TWO forum.

I intend to iteratively improve on TWO, following your feedback, towards creating a rich, stable, final version for v1.0 release!

The following video serves as a brief introduction to TWO:

To accompany the release, here is a video detailing the AudioVisualBach demo program, available in the TWO Alpha download installation file:

So, head over to the Downloads page to grab the installer, for Windows and OS X!

A performance which uses The Wizard of OSC is featured on Euronews in a Musica programme reportage

I was recently involved in a project with the Agalma Foundation, in which two pianists improvise live, and data from their playing and electrophysiology, is used to control live visual music projections.

I was tasked with all software development for the live visuals, and The Wizard of OSC has played an indispensable part in connecting the vast data streams stemming from the performance to the live visuals projections. For the visuals, I used my open-source software Mother.

You will see me behind the desk full of electronics, and can also catch a glimpse of a prototype version of The Wizard of OSC running on a touch-screen laptop.

If you want to read more about the project with the Agalma Foundation, the Musica reportage goes into a bit more detail than this post.


Watch this space!

For now I’m just getting a website up and running, in anticipation of the first public Beta release of The Wizard of OSC (TWO).

In the meanwhile, do subscribe to the newsletter at the bottom of this page, that way you’ll be sure to receive any news on TWO’s development!