Free Open-Source Instrument Host
RackForge is a free and open-source instrument and live-performance host designed to turn a computer, Android phone or Raspberry Pi into a playable musical instrument.
Instead of approaching music software as another traditional DAW, RackForge focuses on something much more immediate:
Connect a MIDI keyboard, choose an instrument and play.
From there, you can combine instruments into Racks, create keyboard splits and layers, organize those setups into Songs and finally arrange complete Setlists for live performance.
Even more interestingly, the same system can run on:
- Windows
- Linux
- Android
- Raspberry Pi
- And MacOs and all the others in Chrome/Chromium Web browsers
There is even a VST3 version for Windows, allowing RackForge itself to run as an instrument inside a DAW.
And the entire project is open source.
A Computer That Behaves More Like an Instrument
RackForge began with a very practical problem.
Its developer wanted to perform live without carrying a laptop and started building a system around an old Raspberry Pi 4B and an Arturia KeyLab Essential mk3.
The idea was to control the system from the small display and physical controls of the MIDI keyboard rather than constantly looking at a computer screen.
Then came another requirement:
Why not play the same setup from a phone?
Supporting Android pushed the project toward a broader cross-platform architecture, eventually producing a host that can use the same musical model across Windows, Linux, Android, Raspberry Pi and the browser.
RackForge therefore sits somewhere between a plugin host, stage instrument, virtual workstation and live-performance environment.
Not Another DAW
RackForge is not designed primarily around:
- Recording tracks
- Editing waveforms
- Arranging audio clips
- Mixing a complete multitrack production
Its workflow instead revolves around playing instruments.
The fundamental structure is:
Instrument → Rack → Song Part → Song → Setlist
That hierarchy makes its purpose immediately clear.
You start with sounds and progressively turn them into a complete performance setup.
PLAY — Choose an Instrument and Start Playing
The simplest RackForge workflow happens inside PLAY.
Choose an installed instrument, select a program and start playing it from:
- A MIDI controller
- The touchscreen
- An on-screen keyboard
- On-screen pads
There is no need to build a DAW project simply to play a software piano or synthesizer.
This makes RackForge particularly interesting for musicians who want a computer or Raspberry Pi to behave more like a hardware workstation.
LIVE — Build a Complete Performance
The LIVE environment takes the idea much further.
RackForge uses several performance objects.
Instrument
An Instrument is an individual playable sound generator.
Examples include a piano, synthesizer or organ.
Rack
A Rack combines and routes one or more instruments.
A Rack can include:
- MIDI channel mapping
- Keyboard ranges
- Transposition
- Velocity shaping
This makes Racks suitable for building layers and splits.
You could, for example, place a piano across the complete keyboard while layering a pad only above middle C.
Or divide the keyboard between bass and synthesizer sounds.
Song Part
A Song Part represents one section of a performance.
It can use individual instruments, complete Racks or both.
This allows different configurations for:
- Intro
- Verse
- Chorus
- Solo
- Outro
Song
A Song organizes those Parts into a musical structure.
Setlist
Finally, a Setlist places multiple Songs in performance order.
The result is a workflow designed specifically around preparing a live show rather than constructing a recording session.
Built-In Instruments
RackForge is not an empty host.
The Standard edition currently includes several instruments covering very different synthesis technologies.
RF — Concert Grand
RackForge includes its own physically modelled grand piano.
And “physically modelled” is important here.
This is not simply a sampled piano library.
There are no piano recordings stored inside the instrument.
Instead, notes are generated mathematically in real time from a physical model incorporating elements such as:
- String stiffness
- String losses
- Hammer behavior
- Felt response
- Soundboard radiation
- Lid geometry
- Microphone positioning
- Damper behavior
- Una corda pedal
The developer describes sixteen modeled instruments, ranging from large concert grands through smaller grands, uprights and a fortepiano.
The model exposes 162 parameters.
RF-106
RF-106 is a virtual-analog synthesizer inspired by the architecture of the Juno-106.
It has its own dedicated PLAY interface and RackForge parameter mappings.
RF-5
RF-5 is a five-voice programmable polyphonic synthesizer.
It expands the built-in synth collection with another classic-style architecture.
RF-7
RF-7 is a six-operator FM synthesizer.
Its architecture includes its own:
- Control panel
- Voice editor
- Cartridge reader
The developer states that it is built using the original instrument’s firmware tables.
RF-Organ
RF-Organ is a physically modelled tonewheel organ.
It includes:
- Two drawbar manuals
- Pedal clavier
- Percussion
- Scanner vibrato
- Integrated rotary speaker
The complete organ can be controlled from a single MIDI bus.
RF-Tines
RF-Tines is a physically modelled 73-key electric piano.
It includes playable and physical voicing controls, factory programs and portable program files.
Unlike a conventional sampled electric piano, its sound is generated through physical modelling.
SoundFonts
An additional RF-Soundfonts instrument is available separately.
This extends RackForge beyond its native modeled instruments and includes access to sampled material such as the YDP Grand Piano.
Standard and Minimal Editions
RackForge is distributed in two configurations.
Standard
The Standard edition includes the host plus its officially bundled instruments.
This means a new installation can immediately produce sound.
Minimal
The Minimal edition contains the complete RackForge host but no instrument plugins.
You can then install only the instruments you actually want.
Importantly, Minimal is not a restricted edition.
Both versions use the same runtime and support the same plugin packages.
The only difference is what comes preinstalled.
Portable .rfplugin Instruments
RackForge introduces its own portable plugin package format:
.rfplugin
A package can contain:
- Audio engine
- Web interface
- Programs
- Artwork
- Resources
The idea is that the same instrument package can move between compatible RackForge platforms.
That is very different from the traditional plugin ecosystem, where separate binaries are normally required for Windows, macOS, Linux and other operating systems.
RackForge’s portable plugins are based around WebAssembly components.
According to the developer, packages include a manifest declaring permissions and a pinned SHA-256 hash, while the host maintains authoritative state.
A Plugin Host That Is Itself a Plugin
One of the more unusual parts of the project is the Windows VST3 preview.
RackForge can itself run as a VST3 instrument inside another DAW.
In this configuration, the DAW provides:
- MIDI
- Timing
- State
- Stereo audio
RackForge does not attempt to open a second audio device.
Its state is stored with the DAW project.
This creates an interesting recursive architecture:
Your DAW hosts RackForge, and RackForge hosts its own portable instruments.
Web Version — Try It Without Installing Anything
One of the easiest ways to understand RackForge is simply to open the Web edition.
It runs locally inside the browser.
There is:
- No account
- No installer
- No remote audio server
Saved instruments and performances remain in the browser.
An on-screen Touch Controller provides a keyboard and pads, meaning you can experiment even without MIDI hardware.
For external MIDI, browser compatibility matters.
Chrome and Edge currently provide the most complete Web MIDI support.
Firefox requires explicit permission, while Safari currently does not expose Web MIDI to RackForge.
The Web version can also be installed from the browser as an app and can continue operating offline once the necessary files have been cached.
For serious low-latency stage use, however, RackForge recommends using one of the native versions.
Windows
The native Windows version supports:
- x86-64
- WASAPI
- ASIO
- Windows MIDI
This makes Windows particularly suitable for building and editing instruments, Racks, Songs and Setlists.
There is also the separate Windows VST3 build.
One current limitation is that the Windows builds are not code-signed, so Windows may display a security warning during installation.
Linux
RackForge also supports Linux x86-64.
The Linux version uses:
- ALSA
- Linux MIDI
- Web control
Rather than presenting a conventional native desktop interface, the current Linux x86-64 version uses a headless engine with a Web interface.
Android
RackForge can turn an Android device into a compact touchscreen instrument.
The current preview supports:
Android ARM64
with:
- Low-latency native audio
- USB MIDI
- USB audio
A class-compliant audio interface can therefore be connected along with a MIDI keyboard.
The current APK is debug-signed.
Raspberry Pi
This may be one of the most interesting RackForge configurations.
The software supports:
Raspberry Pi 4 and Raspberry Pi 5
running a 64-bit Raspberry Pi OS environment.
The Pi can operate as a dedicated instrument that starts automatically at boot.
Control can then happen from:
- MIDI hardware
- A phone
- A tablet
- Another computer through the Web interface
That makes it possible to build a compact standalone software instrument without having a conventional laptop on stage.
Deep MIDI Controller Integration
RackForge is not limited to receiving MIDI notes.
Its .rfcontroller packages can map:
- Keys
- Faders
- Encoders
- Pads
- Buttons
- LEDs
- Displays
to host functions.
The first reference controller is the Arturia KeyLab Essential mk3.
Its integration includes the keyboard’s display, navigation, parameter controls, master volume and pan, lighting and other functions.
A special hardware escape chord can stop audio and return the system to its main menu.
The system is also designed to recover from MIDI disconnections.
If hardware reconnects or part of the system restarts, a handshake restores the control surface state instead of leaving the musician with stuck notes or an interface that no longer corresponds to the software.
More Than 50 MIDI Controllers Mapped
In the original Reddit announcement, the developer states that mappings have already been created for more than 50 MIDI controllers.
There is an important caveat.
The developer personally owns only the KeyLab Essential mk3, so many of those mappings have not yet been tested with the actual hardware.
Users with compatible controllers are therefore being encouraged to report incorrect mappings and other problems.
That is worth keeping in mind given RackForge’s current public-preview status.
Touch Controller
No physical MIDI controller is required for basic use.
RackForge includes an integrated Touch Controller with:
- Keyboard
- Pad grid
This can be operated from a touchscreen or mouse.
That is particularly useful on Android and when testing the browser version.
MIDI Hotplug Recovery
Live performance software needs to deal gracefully with hardware being disconnected.
RackForge includes MIDI hotplug recovery and session restoration.
Its audio engine can even start without an audio device or MIDI controller attached and adopt compatible hardware when it later appears.
That is the kind of feature that matters considerably more on stage than it does in a conventional studio plugin.
Portable Presets
RackForge uses portable:
.rfpreset
files.
These can store instrument state together with plugin identity and version information.
A preset can then be moved to another compatible RackForge host.
The broader objective is straightforward:
prepare a performance on your desktop, move it to a phone or Raspberry Pi, reconnect your controller and continue playing the same show.
Open Plugin Architecture
RackForge is not intended to remain limited to instruments created by its original developer.
Documentation is available for creating new RackForge instruments.
The plugin architecture uses portable host contracts rather than exposing platform-specific audio or filesystem APIs directly to plugins.
Third-party developers can therefore build instruments against the RackForge plugin ABI.
Open Source
RackForge itself, its interfaces and the instruments contained in the main repository are released under:
GPL-2.0-or-later
The plugin SDK is deliberately licensed differently:
MIT OR Apache-2.0
This is an important decision for third-party development.
It means developers using the SDK are not forced to release their own RackForge instruments under GPL simply because they use the official SDK.
They can choose their own licensing terms.
Built in Rust
RackForge is primarily developed in Rust, with WebAssembly playing an important role in its portable plugin architecture.
Its repository includes separate areas for:
- Core engine
- APIs
- SDK
- Plugin runtime
- Windows application
- Android application
- VST3 host
- Headless/Web hosts
- Platform adapters
- MIDI controller drivers
- Instruments
- Web interface
Public Preview
This is perhaps the most important thing to understand before downloading RackForge.
RackForge is currently a public preview.
The project’s own documentation describes the current v0.1.x branch as ready to:
- Explore
- Test
- Play
but not yet as a fully production-signed mature release.
Several limitations remain.
Windows packages are currently unsigned.
Android packages are ARM64 and debug-signed.
Linux x86-64 currently relies on a headless/Web interface.
Browser latency depends on the browser and hardware.
Some optional instruments require separate downloads.
So this is a project worth exploring, but musicians planning a critical live show should test their complete hardware setup thoroughly before relying on it on stage.
Why RackForge Is Interesting
There are plenty of free synthesizers.
There are plenty of plugin hosts.
There are also numerous DAWs.
What makes RackForge interesting is the combination.
It is attempting to build a portable musical environment where the same performance can move between fundamentally different devices.
Imagine preparing a setup on Windows containing:
Piano + synth layer + keyboard split + several songs + complete setlist
and then moving that setup to a Raspberry Pi for the actual concert.
Or using an Android phone as the complete instrument host.
Or opening the same environment in a browser simply to experiment with it.
That portability is much closer to the philosophy of a hardware workstation than a traditional desktop DAW.
Potential Uses
RackForge could be particularly interesting for:
Live Keyboard Players
Create splits, layers, songs and complete setlists without constructing a separate DAW session for every performance.
Raspberry Pi Instruments
Build a compact dedicated software synthesizer around inexpensive hardware.
Android Music Setups
Turn a compatible phone or tablet into a portable instrument host.
MIDI Controller Rigs
Use deeper integration with displays, encoders, pads and other controller hardware.
Educational Projects
Its open-source architecture makes it useful for studying MIDI, synthesis, WebAssembly and plugin-host design.
DIY Hardware Instruments
Combine Raspberry Pi, MIDI hardware, a small display and audio interface to build a custom digital instrument.
Developers
Create portable .rfplugin instruments capable of running across several RackForge platforms.
Strengths
- Completely free
- Open source
- GPL-2.0-or-later host
- Cross-platform architecture
- Windows
- Linux
- Android
- Raspberry Pi
- Browser version
- Windows VST3 version
- ASIO support
- WASAPI support
- ALSA support
- USB MIDI
- USB audio on Android
- Touch Controller
- Racks
- Keyboard splits
- Instrument layers
- MIDI channel routing
- Transposition
- Velocity shaping
- Songs
- Song Parts
- Setlists
- Portable presets
- Portable
.rfplugininstruments - WebAssembly plugin architecture
- Physical MIDI controller integration
- MIDI hotplug recovery
- Built-in modeled piano
- Virtual-analog synths
- Six-operator FM instrument
- Physically modelled tonewheel organ
- Physically modelled electric piano
- SoundFont support available separately
- Standard and Minimal editions
- No account required for the Web version
- Third-party plugin SDK with permissive MIT/Apache-2.0 licensing
Potential Limitations
RackForge is still in public preview, and that should be taken seriously.
The project is evolving quickly and should not yet be treated like a mature commercial live-performance platform.
Windows builds are currently unsigned.
The Android package is ARM64 and debug-signed.
Linux currently uses a headless engine controlled through its Web interface rather than a conventional desktop application.
Browser performance, latency and MIDI capabilities depend on the browser and device.
Safari currently lacks the Web MIDI functionality needed for external MIDI control in the Web edition.
The project’s own .rfplugin ecosystem is also obviously much smaller than established VST3, AU or CLAP ecosystems.
RackForge does not simply host your existing desktop VST collection across every platform. Its main portability concept revolves around instruments specifically packaged for RackForge.
Finally, although more than 50 MIDI controller mappings have reportedly been created, the developer states that only the KeyLab Essential mk3 has been personally hardware-tested so far.
None of those limitations make RackForge less interesting.
They simply reflect how young the project currently is.
Final Verdict
RackForge is one of the more ambitious free music-software projects we have encountered recently.
It does not simply provide another synthesizer or another generic plugin host.
Its goal is broader:
turn almost any suitable computing device into a musical instrument.
Windows computer?
Yes.
Linux box?
Yes.
Android phone?
Yes.
Raspberry Pi?
Yes.
Web browser?
Yes.
And on Windows, RackForge can even become a VST3 instrument inside another DAW.
The included instruments make the project even more compelling. A physically modelled grand piano, electric piano and tonewheel organ sit alongside virtual-analog and FM synthesizers, meaning the Standard installation is already capable of functioning as a small keyboard workstation.
But the most interesting part may be the architecture surrounding those instruments.
Racks, splits, layers, Songs and Setlists transform RackForge from a collection of sound generators into a genuine live-performance environment.
The portable WebAssembly-based plugin system then points toward an ecosystem in which an instrument is not tied to one conventional desktop operating system.
RackForge is still young, and the public-preview status means we would not yet build an important concert around it without extensive testing.
But the underlying idea is excellent.
Instead of asking:
“Which DAW should I open to play this instrument?”
RackForge asks a different question:
“Why can’t the computer simply behave like the instrument?”
For keyboard players, Raspberry Pi musicians, MIDI enthusiasts, DIY instrument builders and open-source developers, RackForge is definitely a project worth watching — and since the Web edition runs without an installation or account, it is remarkably easy to try right now.
Sources :
reddit.com: https://www.reddit.com/r/midi/comments/1wt3c6h/open_source_instrument_host_that_runs_on_windows/
github.com: https://github.com/kalexis1994/rackforge
kalexis1994.github.io: https://kalexis1994.github.io/rackforge
