TWO v0.10.0 release!

I’ve just put up TWO v0.10.0 up for download, Win and MacOS.

This release concludes the massive optimization of the timelines functionality.

When previously it did work well, even with tens of thousands of messages, the feature did start becoming unresponsive with hundreds of thousands of messages. Which, depending on the use case, may not be too uncommon.

I’m happy to say that now, after a lot of work, TWO can work efficiently even with a session comprising a million messages – or more, I stopped testing there.

Already version 0.9.25 contained some of these optimizations, but crucially it lacked the significant optimization in the GUI that now allows also editing / interacting with such large recordings.

Both recording, editing, and playback are vastly optimized. More can be done, but I leave that to a future release.

Next up, I am working on a bug-fixing release.

Meanwhile, please go ahead and download v0.10.0!

Deadmau5 asks for OSC-native DAW – Say no more!

“Ableton’s been cool, just because it’s 18 years in development, it’s nice and stable and all that stuff. And it’s shell-ready. But it really lacks in protocol modularity. It’s just like, oh, here’s MIDI. Here’s an antiquated 60-year-old protocol you guys can still use… like what? Just have OSC! And they do, but you have to do it in Python or use Max for Live, and there’s no native OSC stuff. So actually, a lot of the time I’ve spent during the pandemic was developing a VST that will allow for the interchange of different protocols in and out of any DAW.”

Source: His recent interview posted on Musicradar.

I think it’s time I add Ableton Link support to TWO.

And time to get in touch with Deadmau5!

If you know him do tell him about TWO 🙂

Summary of new TWO features (0.9.18)

Several incremental releases have been made since the last post, and an update post summarizing what is new is long overdue!

Many of the improvements are about performance: TWO is now optimized to better handle very large streams of messages.

Besides many more small additions and bug-fixes which I will not list here, the main improvements are these:

Switching between Mouse or Multi-Touch control

TWO’s GUI can now be switched to “Mouse” mode, where buttons and sliders and smaller than they are in the previously default (Multi-Touch) mode.

When I started creating TWO, multi-touch screens were all the rage, and I made the design decision to make multi-touch a first class citizen. In multi-touch mode, TWO is designed with two simultaneous resolutions in mind, one for the eyes and one for touch. So in TWO’s touch mode all interactive controls are sized to match the size of fingertips, while the visual information is still sized for the eyes.

In hindsight, multi-touch is still far from established, because ergonomically, the mouse and keyboards really are far more comfortable when working at a desk. But, multi-touch is still awesome when using software standing up, or live.

To sum up, with the new Mouse mode, all interactive controls are sized to be as small as makes sense for them to be interacted with using a mouse pointer, thus saving a lot of screen space.

Keyboard Navigation is improved

I now improved the ease with which you can navigate TWO using the keyboard. Arrow keys are now mapped in more views, and I’ve expanded the mapping of keyboard shortcuts.

It’s now just called TWO

While the name started off as an acronym, I now prefer to just use the name TWO directly, no more acronym 🙂 I am working on adding more media control protocols, besides OSC and MIDI, so having one of the protocols used in the name makes less sense.

I hope you find these new improvements useful, and as always, I’m keen to hear what else would be useful for you, and to see what use you make of TWO – stay in touch on the forum:

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: