New Ultra-Low-Latency Interactive Audio Platform, Bela


Andrew McPherson of the Augmented Instruments Laboratory, C4DM let us know that they have launched a new Kickstarter project to fund the development of Bela – a high-performance, ultra-low-latency (< 1ms) platform for audio and sensor processing based on the BeagleBone Black. The project has already met its funding goal, with about a month left in its campaign.

The BeagleBone Black is a community-supported, open-hardware computing platform. Bela provides stereo audio, analogue and digital I/O in a single self-contained package. It combines the processing power of the BeagleBone Black embedded computer with the timing precision and connectivity of a microcontroller.

“I think this might interest Synthtopia (readers) for a variety of reasons,” says McPherson. “The submillisecond latency and audio-rate sensor processing means that digital instruments made with Bela can be faster and more responsive than instruments made on other embedded platforms. Also, the DC-coupled 16-bit analog inputs and outputs could be useful for CV controls.”

Here’s the official intro video:

Tech Details

Here’s what McPherson told us about the Bela’s technology:

Hardware-wise, Bela has stereo audio I/O with onboard speaker amplifiers, 8 channels each of 16-bit analog I/O, and 16 GPIO pins. Every analog and digital channel is automatically sampled at audio rate for precise jitter-free alignment between sensors and audio.

But most important unique feature of Bela is that it has extremely low latency between action and sound, down to 1.0ms round-trip for audio and even down to 100 microseconds from analog input to analog output.


This is much faster than any laptop or embedded Linux board can achieve. We do this by using the Xenomai real-time Linux extensions to run the audio code at essentially bare metal priority, bypassing the kernel drivers to go straight to the hardware. This means we can get audio buffer sizes as small as 2 samples without dropouts, and performance is unaffected by other system load.

Other notable features include an on-board browser-based IDE and an in-browser oscilloscope for visualising audio and sensors. It can be programmed with a lightweight C++ API, or Pd patches can be compiled into optimised C code for the board using the Heavy Audio Tools (

The Bela is available to project backers starting at £45. See the project site for details.

27 thoughts on “New Ultra-Low-Latency Interactive Audio Platform, Bela

  1. They make a strong case for the need for this product: low latency. Their way of achieving it is clever.

    This is a pretty cheap entry into a uniquely powerful little audio platform.

    The minor downsides are that it is limited to 16-bits (as far as I could tell), and that programming is not-for-the-faint-at-heart.

    If other systems could adopt similar philosophies, perhaps the inherent (and famously laughable) latencies of Android could be addressed– however, that would still require both new hardware and new software, which is not likely to happen any time soon.

    1. 16bit ADC is fine for output. Higher dynamic range is necessary only when recording audio which you will later edit. Even 12bit is fine! It’s pretty obvious that it’s more about making it into an instrument rather than some high end audio interface. You can always achieve better quality audio with lots of possibilities, which have been out there for a while already. I personally couldn’t even imagine high end audio coming out from any of such small and cheap device.

  2. I wonder what the actual output voltage of the gpio pins will be? Hopefully high enough to implement 12V per octave CV signals. Also, I would love to see computation times of FFTs calculated on input signals. I wonder if they using the GPU of the beagle bone black to accelerate DSP functions…So many questions! It is a very neat and exciting product nevertheless.

      1. Ahhh! Thanks for the common sense check! Now all I need to do is design a separate module that would step up the 3.3V GPIO outs to a 12 V/octave scheme. I’m new to modular synthesis so bear with me, but how do 12V/octave CV signals work if the bus voltage of eurorack modules is usually -12 V to +12 V? This only would give a range of two octaves? Do controllers step up the voltages?

        1. Eurorack is 1v/octave with a . They are powered by a +12v rail,-12V rail, and +5V rail. Although, I’m not sure of where the number 12V comes from. I think some modules have a max cv voltage of 10V. for pitch Maybe the extra 2V is just extra? Maybe it’s used by the internal components supply voltage? I would like to know actually why 12V.

    1. Hi,
      regarding voltage levels, the answer is in our FAQ page

      > Audio I/O levels depend on the adjustable settings of the audio codec. You can comfortably plug in a guitar, a dynamic microphone, a piezo pickup, most stuff really, having up to 59.5dB of gain at your disposal. You can refer to the TLV320AIC3104 datasheet for more details.
      > Analog ins are in the range 0-4.096V (inputs are 5V tolerant); Analog outs are in the range 0-5V; Digital I/O levels are 0/3.3V. Mind that these are the BeagleBone’s AM3358’s own GPIO pins, so make sure you NEVER exceed 3.3V or you will brick your BeagleBone Black.

      If you want to use this to control, e.g.: an eurorack module, in order to take advantage of the full voltage range, you will probably need some external circuitry to scale and shift the voltages.

  3. seems much more exciting for engineers than end-user musicians…

    right now its all speculative as far as actual instruments are concerned

    1. ham radios?
      im confused…
      i understand this is an “open-ended” product to be implemented in other products, but wtf? ham radio?

      1. And why not? There’s plenty of interesting developments in the amateur radio world.
        More interesting than squashing 1960’s synth circuits into a 3U case 🙂

    1. It’s very similar approach. The latency thing is actually almost the same ( Axoloti does not have so many ins/outs, but has jack connectors already on board! 🙂 If you are a musician with no or little experience with Pure Data or even C++ then Bela will probably end in the shelf. Axoloti comes with its own Patcher which is quite easy to use and you don’t need any knowledge of programming. It is like working with modular synth ( Axoloti has many pins for connecting different mechanical, AV devices, controllers. If you want to program Axoloti, you can do that, it is opened.

      1. From our FAQ

        > Axoloti is a bare-metal microcontroller board with an 168MHz ARM Cortex-M4 microcontroller on it. Bela is a computer with a 1GHz ARM Cortex-A8 CPU which has much more processing power and built-in vector floating point support. Bela runs on Linux and, as such, gets all the extra functionalities that come with it (storage, network, USB, onboard compiling).
        > At the same time, Bela runs ON TOP of Linux (that is: at a higher priority), so that the audio performance are never interrupted by what else is happening on the board: you get the best of Linux without the performance overhead.
        > Compared to Axoloti, Bela also has 16-bit analog inputs and outputs (8 each) and onboard speaker amplifiers. On the other hand, Axoloti has built-in 5-pin MIDI jacks which Bela does not have, though Bela can use USB MIDI. Axoloti has its own graphical development environment, where Bela uses either Pd or C++.

        Additionally, note that every Bela kit comes with audio I/O connectors in a break out cable. We ship with 1/8″ inch connectors, but you can easily solder 1/4″ inch connectors instead.

        1. Pure Data on Bela relies on a compiler (“heavy”) that is only available as a cloud service. “Heavy” is not open source, and not available as a binary download.

          Axoloti has 15 available 12-bit resolution analog inputs, two of those channels can also switch to 12-bit resolution analog outputs. Also UART, SPI, I2C and multiple PWM’s are available for expansion with other electronic parts.

          Axoloti can use a USB midi-class devices too on the USB host. Its USB device port will also present itself as a USB-midi device to your computer.

          1. Thank you very much Johannes for your clarifications, we are updating our FAQs with the details you provided.
            We have not had a chance to try an Axoloti in person yet, but from what we see it is a great tool and a lot of work has been put into the custom patcher and building environment and we see that the community loves it.
            Would you mind providing us with additional details about the sampling rate of the analog channels on the Axoloti, so that we can include them into our FAQs? I cannot find the specifications anywhere on your website.

            I would say that there is some overlap in the applications of Bela and Axoloti, but also some differences. The design goals are quite different, as Bela runs a full-stack Linux OS trying to squeeze all the power available out of the 1GHz ARM A8, with an approach that is entirely new.

            Regarding the Heavy compiler, you are very right, it is not open source and not available for download. Their web service, though, is extremely fast, we can get patches compiled to C within 1 second, and the code it returns is licensed MIT for non-commercial use.

            1. Currently the gpio analog channels on Axoloti Core are sampled at 3kHz. That is not a hardware limitation, but faster conversion has not been developed since there is little demand. On paper, the ADC supports 2MS/s, multiplexed over 16 channels that’s 125kS/s.

  4. i like low latency too, of course.

    but what does the systems latency tell me about actual programs running on it?
    I can see that a sequencer for example, or a controller based on it would be superfast.

    But as soon as you start with PureData etc its your code that does add latency.

    Anyhow i ike it 🙂

    1. Hi, from our FAQ

      How do we get low latency running PureData?
      > First, we are not running the Pd program itself, and second one, we are not using the Linux ALSA drivers. Pd patches are compiled into C code using the Heavy Audio Tools. The C code produced is highly optimised and is automatically wrapped into our C++ API. This bypasses the whole Linux kernel (and ALSA) and allows it to run with buffer sizes as small as 2 audio samples, giving a roundtrip latency below 1ms for audio (because the ADC/DAC have some built-in latency) and below 100us for analog (whose converters are faster).

Leave a Reply

Your email address will not be published. Required fields are marked *