Two Different Ways to Control Plugin Parameters
At first glance, TouchMod and TouchOSC seem to solve a similar problem. Both allow musicians, producers and sound designers to use a touchscreen instead of relying solely on a mouse and keyboard.
Both can be used for sound design, music production and live performance. Both make it possible to interact with software in a more hands-on way.
The similarity ends when you look at how they communicate with software and how they control plugin parameters.
Understanding this difference helps explain why the two platforms often feel very different in real-world use.
What Is TouchOSC?
TouchOSC is a touchscreen controller environment that allows users to create custom control surfaces.
A TouchOSC layout can contain:
- Faders
- Knobs
- Buttons
- XY pads
- Custom widgets
These controls send MIDI or OSC messages to software or hardware devices.
TouchOSC itself does not usually control plugin parameters directly. Instead, it sends messages that another application, host or plugin interprets and maps to specific parameters.
A typical workflow looks like this:
TouchOSC → MIDI or OSC → MIDI Learn or Mapping → Plugin Parameter
This architecture is one of TouchOSC's greatest strengths. Because it uses standard communication protocols, it can work with a wide range of DAWs, plugins, synthesizers and hardware devices.
What Is TouchMod?
TouchMod takes a different approach.
Rather than acting as a generic controller, TouchMod focuses on direct interaction with plugin parameters. The touchscreen becomes part of the plugin itself instead of functioning as a separate control surface.
The workflow starts with the plugin rather than with a custom controller layout.
TouchMod works as a wrapper around the plugin and communicates directly with the plugin's exposed parameters. Instead of creating MIDI assignments or configuring mapping layers, users simply select or learn the parameters they want to control.
Learning parameters is intentionally straightforward. Move a knob, slider or control inside the plugin, and TouchMod immediately detects the parameter. There is no need to assign MIDI CC numbers or create a separate control scheme before you can start interacting with the sound.
The workflow looks like this:
Plugin Parameter → TouchMod → Touch Interaction
Because TouchMod works directly with plugin parameters, the connection between gesture and sound remains simple and immediate.
The Difference Between Messages and Parameters
This distinction may sound technical, but it has practical consequences.
A MIDI message is not the same thing as a plugin parameter.
A MIDI message is information being transmitted.
Examples include:
- MIDI CC 74
- Pitch Bend
- Note Velocity
A plugin parameter is an actual setting inside a synthesizer or effect.
Examples include:
- Filter Cutoff
- Resonance
- Reverb Mix
- Wavetable Position
With MIDI-based workflows, a message must first be connected to a parameter.
With direct parameter control, the interaction happens closer to the parameter itself.
That difference affects setup, workflow and the overall experience of interacting with software instruments and effects.
Why Resolution Matters
One area where these approaches can differ is control resolution.
Standard MIDI CC Resolution
Traditional MIDI Continuous Controllers use 7-bit values.
This means:
0–127
or 128 possible positions.
For many applications this is more than sufficient.
Volume adjustments, automation recording and general controller tasks often work perfectly well with 128 steps.
However, some synthesizer parameters are extremely sensitive.
Examples include:
- Filter cutoff
- Fine pitch adjustments
- FM amount
- Wavetable position
- Morphing controls
In these situations, limited resolution can sometimes result in less smooth transitions.
TouchOSC Is Not Limited to 7-Bit MIDI
It is important to note that TouchOSC is not restricted to traditional MIDI CC messages.
Depending on the setup, it can also work with:
- 14-bit MIDI messages
- Pitch Bend data
- OSC communication
- Custom scripting
OSC in particular supports much higher precision than standard MIDI CC.
As a result, TouchOSC can deliver highly accurate control when the receiving software supports these protocols.
The actual limitation often depends on the entire signal chain rather than on TouchOSC itself.
The Mapping Layer
Even when higher-resolution communication is available, many TouchOSC workflows still involve a mapping stage.
For example:
TouchOSC → MIDI CC → DAW Mapping → Plugin Parameter
This is not necessarily a disadvantage.
In fact, it is one of the reasons TouchOSC can communicate with so many different applications and devices.
The trade-off is that an additional layer exists between the touchscreen and the parameter being controlled.
For many users this flexibility is exactly what makes TouchOSC attractive.
Direct Plugin Parameter Control
Modern plugin formats such as VST3 expose parameters as continuous values rather than traditional MIDI CC data.
Instead of 128 discrete steps, parameters are typically represented as floating-point values.
Conceptually this looks like:
0.0 → 1.0
with a very large number of possible intermediate positions.
TouchMod is designed around direct plugin parameter control.
Instead of generating MIDI messages that must be interpreted and mapped before reaching the plugin, TouchMod communicates directly with the plugin's exposed parameters. This removes the intermediate mapping layer that is common in many controller-based workflows.
A traditional controller setup often looks like this:
Touchscreen → MIDI or OSC Message → Mapping Layer → Plugin Parameter
With TouchMod, the path is much shorter:
Touchscreen → TouchMod → Plugin Parameter
This direct approach creates a workflow centered around the actual controls that shape the sound.
Parameters can be learned instantly by moving a control inside the plugin interface, allowing users to start working immediately without spending time on controller configuration.
For musicians and sound designers, this often feels more like interacting with the instrument itself rather than controlling it from a distance.
Why This Matters During Performance
Resolution is only part of the story.
The more significant difference often comes down to how interaction feels during performance.
With a traditional controller workflow:
Touchscreen → Virtual Control → Message → Parameter
The performer interacts with a control object that represents a parameter.
With direct parameter interaction:
Touchscreen → Parameter
The performer works much closer to the actual sound-shaping controls.
This can create a more immediate relationship between physical gesture and sonic result.
Small movements can feel more connected to what is happening inside the plugin because fewer layers exist between the performer and the parameter being adjusted.
Multiple Parameters at the Same Time
Modern sound design often involves several parameters moving together.
For example:
- Cutoff rises
- Resonance increases
- Delay feedback changes
- Reverb mix decreases
With traditional controller workflows, these relationships are frequently created through mappings, macros or controller assignments.
TouchMod approaches this differently.
One of its strengths is multitouch interaction.
TouchMod can control up to eight plugin parameters simultaneously using four fingers on a touchscreen. Multiple parameters can be grouped together and manipulated in real time, allowing complex changes to occur through a single gesture.
For example, a single movement can influence:
- Filter cutoff
- Resonance
- Delay feedback
- Reverb mix
- Oscillator shape
- Modulation depth
- Distortion amount
- Effects balance
This makes it possible to create evolving textures, expressive transitions and performance gestures that would be difficult to reproduce with a mouse or a single hardware controller.
Because multiple parameters can move together, TouchMod encourages a more expressive and performance-oriented approach to sound design. Instead of adjusting one parameter after another, musicians can shape several aspects of a sound simultaneously.
The result is a touchscreen workflow that feels closer to playing an instrument than editing software.
Controller-Centric vs Plugin-Centric Workflows
Perhaps the simplest way to describe the difference is this:
TouchOSC
The workflow begins with the controller.
You design controls and then connect those controls to software, hardware or plugins.
TouchMod
The workflow begins with the plugin.
You work directly with plugin parameters and use touch as the method of interaction.
Neither philosophy is inherently better.
They simply prioritize different aspects of the creative process.
TouchOSC emphasizes flexibility and universal control.
TouchMod emphasizes direct interaction and performance-oriented parameter manipulation.
Which One Should You Choose?
TouchOSC may be the better choice when:
- You need a universal controller platform.
- You work extensively with MIDI hardware.
- You want complete freedom over interface design.
- You need to control multiple applications from a single layout.
- You enjoy creating custom control systems.
TouchMod may be the better choice when:
- You want direct access to plugin parameters.
- You prefer a plugin-centered workflow.
- You want expressive multitouch interaction.
- You regularly perform sound design using multiple parameters at once.
- You want to reduce reliance on MIDI mapping and controller configuration.
Final Thoughts
TouchOSC remains one of the most flexible touchscreen controller platforms available. Its strength lies in creating custom control surfaces that can communicate with a wide range of software and hardware.
TouchMod approaches the problem from a different direction. Rather than starting with messages, mappings and controller layouts, it starts with the plugin itself and the parameters that shape the sound.
By communicating directly with plugin parameters and supporting simultaneous control of up to eight parameters through multitouch interaction, TouchMod offers a workflow focused on immediacy, expression and hands-on sound design.
For musicians who want a touchscreen to become an extension of the plugin rather than an external controller, that distinction can make a significant difference in daily use.