Duckport MIDI vs. Bome, ShowCockpit, and Free Tools

At some point, nearly every show computer needs one application to talk to another.

Maybe REAPER needs to send MIDI Timecode to grandMA3 onPC. Maybe an APC Mini needs to control executors. Maybe a playback machines needs to send MTC to lasers. Or Windows decides to be a bit Windows. 

This is where MIDI routing and translation tools enter the chat.

The problem is that these tools are not all doing exactly the same job. Duckport MIDI is a focused Windows routing utility. loopMIDI creates virtual cables, while MIDI-OX monitors, routes, and manipulates MIDI data. Bome MIDI Translator Pro is a deep translation and automation engine. ShowCockpit is closer to a modular show-control integration platform.

Comparing them is a little like comparing a patch bay, a test bench, a programmable robot, and an entire production desk. They overlap, but the best choice depends heavily on what you are actually trying to accomplish.

There is no universal winner here. The goal is to choose the smallest tool that solves the real problem without creating three new problems during soundcheck.

The quick comparison

• loopMIDI with MIDI-OX: A proven utility stack for creating virtual ports, inspecting messages, and handling basic routing or mapping. Low software cost, but more setup, more windows, and more opportunities for port-direction confusion.
• Bome MIDI Translator Pro: The strongest option when you need advanced MIDI translation, conditions, variables, timers, layers, keystrokes, mouse actions, or custom logic. Extremely capable, but the learning curve is real.
• ShowCockpit: The broadest show-integration option. It can connect controllers, lighting consoles, video software, timecode formats, OSC, and other protocols through a modular driver system. It is more expensive and more involved than a simple MIDI router, but it can replace several separate utilities.
• Duckport MIDI: A clean choice for straightforward MIDI routing on a Windows 11 show computer. Application-specific routing, lightweight, with plug & play workflow It is not designed for deep translation logic or whole-show integration.

These tools do not all solve the same problem

Before comparing features, it helps to define the job.

If all you need is to send MTC from REAPER to grandMA3 onPC, you need a virtual MIDI route. You probably do not need a scripting engine, device-specific feedback system, and enough conditional logic to launch a satellite.

If you need one controller button to do different things based on the active layer, translate MIDI CC into notes, launch applications, send keystrokes, and change mappings when a device reconnects, a basic router will not be enough.

If you want an APC controller to operate grandMA3 through OSC, receive button feedback, convert LTC to MTC, trigger Resolume, and talk to a Stream Deck from one project, you are no longer shopping for a simple MIDI cable. You are building a small show-control ecosystem.

Feature count only matters when those features solve a problem you actually have. Otherwise, they are just more menus waiting to become emotionally significant.

Duckport MIDI: focused, clean, and intentionally simple

Duckport MIDI is a modern Windows MIDI routing utility designed specifically for show computers. Its main job is to make routes between playback software, consoles, controllers, and show applications easy to understand.

It is not trying to be a scripting language. It is not trying to control every lighting console, video server, and coffee machine through one project. It is a patch layer.

That narrower scope is the main feature.

Where Duckport MIDI is strong

• Low learning curve: The interface is built around readable inputs, outputs, routing, traffic state, and device visibility.
• Focused workflow: It is designed for show-computer jobs such as routing MTC from a DAW to lighting or laser software.
• Clean troubleshooting: A fixed patch view and visible MIDI traffic make it easier to see whether data is entering and leaving the expected port.
• Lightweight scope: It is not loading a giant collection of device drivers, protocol translators, visual programming elements, and scripting tools when all you need is a route.
• DuckTC integration: It serves as the shared MIDI routing layer for DuckTC’s LTC-to-MTC output and future Duck Lights tools.

A practical example is REAPER generating MTC, Duckport MIDI carrying it to grandMA3 onPC, and a MIDI controller feeding the same show computer through a clearly defined route.

That is a normal production workflow. It should not require a degree in virtual plumbing.

Where Duckport MIDI is limited

Duckport MIDI is not especially feature-rich compared with Bome or ShowCockpit. That is not an insult. That is the product.

It is not currently the best choice when you need:

• Complex MIDI message translation
• Conditional rules and variables
• Layers of controller mappings
• Keystroke or mouse emulation
• Lua scripting
• Device-specific lighting console integrations
• Large multi-protocol projects involving OSC, HTTP, Art-Net, video, and audio applications

Duckport MIDI also does not convert LTC audio by itself. For that workflow, DuckTC receives and diagnoses the LTC signal, converts it to MTC, and sends that MTC through Duckport MIDI.

The big limitation: Windows 11 only

Duckport MIDI is designed for Windows 11. That is a real limitation, and it should not be buried under seventeen paragraphs of marketing glitter.

If your show computer is locked to Windows 10 because of drivers, console software, hardware compatibility, company policy, or the perfectly valid belief that show computers should not be upgraded five minutes before doors, Duckport MIDI may not be the right tool.

In that situation, Bome MIDI Translator Pro or the loopMIDI and MIDI-OX stack may be a better fit. Both have options that support older Windows environments.

A free application is not actually free if using it requires replacing a working computer, changing an operating system, rebuilding every driver, and spending two rehearsal days learning which USB device has developed opinions.

Reliability and maturity

Duckport MIDI is designed around reliability through simplicity. Fewer translation layers and fewer configuration systems mean fewer places for a route to become creatively incorrect.

That design can make it feel more dependable for straightforward jobs, but there is an important fairness note: Duckport MIDI is newer and currently in beta. It does not yet have the same long public field history as Bome, MIDI-OX, or loopMIDI.

For show-critical use, test cold starts, controller reconnection, application launch order, port persistence, and recovery after a device is unplugged. New and clean is great. Tested on your actual rig is better.

Best fit: Windows 11 users who need readable, straightforward routing between playback, timecode software, consoles, and a controller without building a full custom automation project.^[1]

loopMIDI and MIDI-OX: the classic free utility stack

loopMIDI and MIDI-OX are often paired because they handle different parts of the job.

loopMIDI creates virtual MIDI ports. MIDI-OX can monitor MIDI traffic, route messages, filter data, map messages, log activity, and help diagnose what a controller or application is actually sending.

One creates the roads. The other directs traffic and writes down license plates.

Where the free stack is strong

• Excellent diagnostic visibility: MIDI-OX is still extremely useful for seeing raw incoming and outgoing MIDI messages.
• Flexible basic routing: You can connect applications through loopMIDI ports and use MIDI-OX to inspect or redirect the stream.
• Useful on older Windows systems: loopMIDI’s official page lists support from Windows 7 through Windows 10.
• Modular: You can use loopMIDI by itself when you only need a cable, or add MIDI-OX when you need monitoring and mapping.
• Established workflow: A lot of technicians already know these tools, and there is years of community knowledge around them.

MIDI-OX is especially valuable as a troubleshooting instrument. When a controller is not doing what the lighting console expects, MIDI-OX can tell you whether the button is sending a Note, Control Change, Program Change, or something completely different from what the label promised.

Sometimes the best feature is simply being able to prove which application is lying.

Where the free stack gets annoying

You are managing at least two applications, and neither was designed specifically around current show-control workflows.

That means dealing with:

• Separate port creation and routing tools
• Input and output names that can be easy to reverse
• Multiple configuration windows
• Application launch order
• Profiles and maps stored in different places
• An interface that carries some strong “Windows utility from another era” energy

loopMIDI’s virtual ports only exist while loopMIDI is running. It can be set to launch automatically, but that becomes another startup item that must be tested and documented.

“Free” needs an asterisk

MIDI-OX is distributed as freeware. The loopMIDI developer states that the software on his site is free for private, non-commercial use and asks users with commercial interests to make contact.

That distinction matters for touring companies, rental houses, production vendors, and other businesses. Do not automatically interpret “downloadable at no charge” as “licensed for every commercial production use forever.”

The real total cost may also include the operator time required to install two utilities, create ports, save routing profiles, configure autostart, and explain the setup to the person covering your position tomorrow.

A current Windows 11 wrinkle

Microsoft’s 2026 Windows MIDI Services rollout has included acknowledged issues involving dynamic virtual ports such as loopMIDI not always appearing. Microsoft began rolling out fixes, but this is still relevant context for anyone maintaining a Windows 11 show computer.

That does not make loopMIDI bad. It means the operating system underneath virtual MIDI is changing, and show computers remain deeply committed to finding new ways to humble us.

If you use this stack on Windows 11, test it against the exact Windows build installed on the machine. Do not assume that a setup working six months ago will behave identically after an operating system MIDI update.

Best fit: Older Windows computers, budget-conscious users, MIDI technicians who want strong raw-message diagnostics, and operators comfortable managing a traditional multi-utility workflow.^[2]

Bome MIDI Translator Pro: extremely powerful, occasionally a lot

Bome MIDI Translator Pro is much more than a MIDI router. It is a MIDI event processor, mapping tool, translation engine, and automation platform.

It can take an incoming event, inspect it, run rules, store values, apply conditions, change routes, send another MIDI message, press a keyboard shortcut, move the mouse, launch a program, start a timer, or talk through a serial port.

That is serious feature depth.

Where Bome is strong

• Advanced translation: Turn notes into CC messages, remap channels, change values, filter events, or construct new MIDI messages.
• Conditional logic: Use variables, expressions, labels, conditions, and rules to make mappings behave differently in different situations.
• Layers and presets: One controller can perform different jobs based on the active preset or operating state.
• Computer automation: MIDI can trigger keyboard shortcuts, mouse actions, timers, applications, and other non-MIDI events.
• Cross-platform support: The current version supports Windows 10, Windows 11, and current macOS releases.
• Mature support resources: Bome has extensive tutorials and an active support forum.

If you need a controller button to perform one action when a page is active, another action when a modifier is held, and a third action after a timer expires, Bome is built for that kind of nonsense. Respectfully.

The learning curve

Bome is powerful because it exposes a lot of the machinery. The downside is that you may need to understand the machinery.

Users can encounter concepts such as:

• Physical ports versus virtual ports
• Port aliases
• Direct MIDI routes versus translator actions
• Note messages versus Control Change messages
• Raw hexadecimal MIDI data
• Global and local variables
• Rules, conditions, timers, and preset states
• Windows applications competing for exclusive access to the same port

A basic route can be simple once you understand the interface, but troubleshooting a larger project can feel like opening a road case where every adapter is black and none of them are labeled.

The MIDI 1.0 roots

Bome’s core workflow is grounded in the classic MIDI model of ports, channels, notes, Control Change messages, raw bytes, and virtual cables. In practical show-control terms, that is mostly the MIDI 1.0 world.

That does not make it obsolete. A huge amount of live-production hardware and software still speaks classic MIDI, and Bome is actively maintained. Version 1.9.2 was released in December 2025.

The nuance is that troubleshooting can require older MIDI vocabulary and raw-message thinking. Newer users may find themselves staring at values such as 90 3C 7F and wondering when the lighting job became a computer science elective.

Reliability needs a fair explanation

I have personally experienced occasions where Bome did not launch correctly or appeared to stop forwarding messages until it was restarted. That experience is worth mentioning because this is a live-production article, not a brochure.

It is not fair, however, to conclude that Bome is universally unreliable.

Public support threads include users reporting that MIDI output suddenly stopped, but some of those cases were eventually connected to another application owning the MIDI port, incorrect message types, routing choices, or alias configuration rather than a confirmed Bome software failure.

This is part of the complexity tax. When an application can do almost anything, there are many more places to look when it does not do the thing.

Cost and ownership

Bome MIDI Translator Pro is currently listed at €79, approximately US$90. One license covers Windows and macOS, but the official license language says to run that license only once at a given time.

That matters if your production requires a simultaneously running primary and backup computer. Confirm whether you need another license before discovering the answer in the middle of a redundancy meeting.

For advanced applications, €79 can be excellent value. A few hours of Bome logic might replace custom software or several separate utilities.

For a single REAPER-to-MA3 MTC route, the purchase price may be less important than the setup burden. Using an automation engine as a virtual cable can be like driving a forklift to move one folding chair. It works. It is just a lot of forklift.

Best fit: Advanced controller translations, conditional actions, custom MIDI processing, keyboard automation, and operators willing to learn a deep tool in exchange for extensive control.^[3][6]

ShowCockpit: broad, modern, and built for integration

ShowCockpit for Windows is the broadest platform in this comparison.

It is designed to integrate audio, video, lighting, effects, controllers, timecode, and multiple control protocols. Instead of only exposing raw MIDI routes, ShowCockpit uses drivers and project elements that provide controls and functions.

Its mapping system is not exactly a traditional node graph, although it can feel node-like when building larger projects. The official workflow uses elements and mappings organized around Functions, Parameters, and Controls.

Where ShowCockpit is strong

• Device-specific integrations: Drivers can expose useful functions for lighting consoles, video software, controllers, timecode systems, and other applications.
• Controller mapping: Supported controllers can be easier to configure than building every raw MIDI translation manually.
• Feedback workflows: Some integrations can return button, fader, page, or state feedback to compatible controllers.
• Protocol conversion: ShowCockpit can work across MIDI, OSC, LTC, MTC, Art-Net Timecode, HTTP, and other protocols, depending on the installed drivers.
• Broad show integration: One project can coordinate controllers, lighting software, video systems, playback, and timecode tools.
• Active development: Current releases continue to add drivers, improve compatibility, and fix integration issues.

For an LD building an APC controller surface for grandMA3, adding timecode conversion, and controlling Resolume from the same computer, ShowCockpit may eliminate several separate utilities.

That is where its larger scope starts paying rent.

What lighting programmers seem to like

Public feedback from lighting programmers includes users who moved from Bome-based setups and found ShowCockpit’s controller mapping and LTC-to-MTC conversion much easier to configure.

The device-driver approach can reduce how much raw MIDI and OSC knowledge the operator needs. When the correct driver exists and matches the software version, you can work with recognizable console functions instead of translating everything through notes, CC numbers, keystrokes, and interpretive dance.

ShowCockpit is also commonly mentioned in MA programming communities as a go-to option for turning general MIDI controllers into more console-like control surfaces.

Where users can still run into trouble

A device-specific driver simplifies the work, but it also creates another compatibility layer.

If grandMA3, Resolume, a controller firmware, or another connected application changes its API or behavior, the ShowCockpit driver may need an update. Public discussions include users who had some MA3 functions working while others returned errors or did nothing, even after following the documented connection process.

Other users have encountered controller-profile issues such as faders responding in unexpected pairs, offsets between physical and software controls, or feedback behaving differently from the intended mapping.

That is not unique to ShowCockpit. It is the general tradeoff of using device-aware integrations. They can make the correct workflow much easier, but they depend on both sides continuing to agree about the handshake.

The licensing system takes a minute

ShowCockpit’s Basic version currently starts at €39, after which users can purchase the drivers they need. Current store examples include:

• Generic MIDI: €10
• MIDI Output: €10
• MTC Input or Output: €10 each
• LTC Input or Output: €25 each
• grandMA3 OSC: €25
• Resolume Arena: €30

The Pro version is currently shown at a sale price of €249, with a regular listed price of €319. Pro includes all available drivers, future drivers, pre-release drivers, and Lua scripting.

The modular model can be economical when you only need two or three drivers. It can also become difficult to estimate when the project starts growing.

You may begin with a MIDI controller and MA3, then add MTC, LTC, Resolume, Companion, another controller, and a backup machine. Suddenly the license plan has become a production department of its own.

By default, Basic and Pro licenses register to one computer at a time. Additional simultaneously active machines require Extra PC upgrades. Moving a license between computers also requires internet access to unregister and register it.

That is manageable, but it must be included in backup planning. A licensing system is not confusing when you understand it. It is just inconvenient to learn during a machine failure.

What about processor use?

ShowCockpit has a broader application scope than Duckport MIDI. A project can contain multiple active drivers, elements, mappings, feedback paths, network connections, protocol conversions, and UI components.

It is reasonable to expect a larger potential processor and memory footprint than a focused virtual MIDI router. More moving parts generally require more resources.

However, I did not find a credible apples-to-apples benchmark proving that ShowCockpit creates a meaningful processor problem on a normal show computer. It would be unfair to present that assumption as measured fact.

The correct approach is to test the actual project:

• Run the real controller mappings.
• Enable all required drivers.
• Run the console, playback, or media software at the same time.
• Watch processor and memory use.
• Test feedback-heavy pages.
• Disconnect and reconnect controllers.
• Leave the system running for several hours.

A simple ShowCockpit project may run perfectly happily. A large integration project deserves the same load testing as any other show-control system.

Best fit: Operators who need broader integration across controllers, consoles, timecode, audio, video, and multiple protocols, especially when supported device drivers can replace a pile of custom mappings.^[4][5]

Total cost of ownership: the price tag is only the first cue

The purchase price is the easiest number to compare and often the least important one.

Total cost of ownership includes:

• Software licenses
• Operating system and hardware requirements
• Setup time
• Training time
• Backup-machine licensing
• Configuration maintenance
• Compatibility testing after updates
• Troubleshooting during rehearsals
• The number of people on the crew who understand the system

Duckport MIDI ownership cost

On an existing Windows 11 machine, Duckport MIDI has a very low current acquisition cost and a relatively low training burden.

On a Windows 10 machine that cannot be upgraded, the ownership cost may include a new computer, driver testing, application reinstallation, and a complete system rebuild. In that situation, the “free” option may become the most expensive choice.

loopMIDI and MIDI-OX ownership cost

The initial software cost is low, but the stack requires more configuration, documentation, and operator knowledge. Commercial users should also verify the loopMIDI licensing terms rather than assuming private-use terms apply to a professional production.

This stack has good value when someone on the crew already understands it. Its cost rises when every substitute programmer needs a guided tour through four windows and six virtual port names.

Bome ownership cost

Bome has a straightforward one-time purchase price, but it can require substantial setup and learning time.

That time is completely justified when the project needs Bome’s advanced logic. It is harder to justify when the project only needs a clean virtual cable.

Bome’s real value appears when it replaces custom code, several utilities, or a more expensive hardware control solution.

ShowCockpit ownership cost

ShowCockpit can start inexpensively with Basic and a few drivers, then grow as the system expands. The cost becomes easier to justify when its drivers save days of custom mapping or replace multiple separate applications.

Backup-machine licensing, additional drivers, and future system expansion should be priced from the beginning. Buying one inexpensive driver at a time feels cheap until the project quietly becomes a small civilization.

Which tool should you choose?

REAPER MTC to grandMA3 onPC on one Windows 11 computer

Start with Duckport MIDI.

This is exactly the kind of focused route it is designed to handle. It gives you a readable path between the DAW and MA3 without making the operator build translation rules that are not needed.

A Windows 10 show computer that cannot be upgraded

Consider Bome or the loopMIDI and MIDI-OX stack.

Bome currently supports Windows 10. loopMIDI’s official support list covers Windows 7 through Windows 10. Either may be more sensible than rebuilding a stable show computer around a Windows 11-only application.

One controller needs complicated conditional behavior

Choose Bome MIDI Translator Pro.

If buttons need layers, variables, timers, alternate outputs, keystrokes, or different behavior based on state, Bome is the deepest tool in this comparison.

A MIDI controller needs to feel like a lighting console surface

Consider ShowCockpit.

Its device and console drivers, mapping system, and feedback features can be much more efficient than manually creating every translation. Just confirm that the controller, console version, and required driver are currently compatible.

You need MIDI monitoring and raw-message diagnosis

Use MIDI-OX.

Even when another application handles the final route, MIDI-OX remains useful as a diagnostic tool. It can answer the foundational question: “What is this controller actually sending?”

You need a virtual cable on an older Windows machine

Use loopMIDI, subject to the applicable license terms.

It is a straightforward way to create virtual ports between applications. Pair it with MIDI-OX when you need monitoring, filtering, or additional routing.

You need LTC converted to MTC

Use DuckTC with Duckport MIDI for a focused Windows 11 workflow, or evaluate ShowCockpit’s timecode drivers when the conversion is part of a broader integration project.

Duckport MIDI alone is the routing layer. DuckTC performs the LTC decoding, signal monitoring, and MTC conversion.

You need macOS support

Bome is the clear option among these four choices.

Duckport MIDI is Windows 11 only, loopMIDI and MIDI-OX are Windows utilities, and the ShowCockpit product discussed here is ShowCockpit for Windows.

Best practices no matter which tool you choose

• Choose the narrowest tool that solves the real problem. Feature depth is valuable only when the production uses it.
• Test from a cold boot. A route that works after six applications have been opened in the perfect order may not survive a show-machine restart.
• Document port direction. Write down what creates each port, what sends to it, and what receives from it.
• Use clear names. “REAPER MTC OUT” is better than “MIDI Port 4.” Good labels are free. Confusion is expensive.
• Test device reconnection. Unplug the controller or interface, reconnect it, and verify that the application recovers.
• Watch for port ownership. On classic Windows MIDI paths, another application may open a port first and prevent the intended application from accessing it.
• Save the installer and configuration. Do not assume the exact version will still be available when rebuilding a backup machine in another country.
• Plan the backup license. Confirm whether a second computer can run simultaneously before calling the system redundant.
• Freeze show-machine updates. Test operating system, driver, console, and utility updates before introducing them to the production environment.
• Measure actual resource use. Do not decide that an application is “lightweight” or “heavy” based only on how modern the interface looks.
• Keep a fallback route. A simple alternate MIDI path is more useful than a beautiful configuration file nobody can understand at show speed.

The honest conclusion

Duckport MIDI is the best fit when the requirement is simple, the computer runs Windows 11, and the crew values a clean, focused routing interface. It is intentionally not as deep as Bome or ShowCockpit. That simplicity is the point.

loopMIDI with MIDI-OX remains a useful and affordable utility stack, particularly on older Windows machines and for operators who need strong MIDI diagnostics. The tradeoff is more configuration, more legacy workflow, and more pieces to maintain.

Bome MIDI Translator Pro is the strongest tool for advanced translation and custom logic. It can solve problems the simpler tools cannot touch. It can also be confusing, especially when raw MIDI, aliases, variables, routes, and Windows port behavior all become part of the troubleshooting conversation.

ShowCockpit is the broadest and most integrated option. Its drivers and mapping system can make complicated controller, lighting, video, and timecode workflows surprisingly approachable. Its licensing and project architecture require more planning, and its device-specific integrations introduce compatibility dependencies that a simple MIDI router does not have.

Pick Duckport when you need a clean patch bay. Pick MIDI-OX and loopMIDI when you want the classic utility toolbox. Pick Bome when you need to program the traffic. Pick ShowCockpit when you are building the whole intersection.

And if Duckport MIDI is not the right answer because your machine cannot run Windows 11 or your workflow needs much deeper automation, use the tool that fits the rig. Production software should solve show problems, not win brand loyalty points.

The best MIDI utility is the one your crew can understand, restart, and troubleshoot five minutes before doors.

That is the move.