Comparing Axoloti

How is it different from Pure Data or Max?

Those work by dynamic invocation of methods of objects at runtime. For non-audio signals this is event-driven. They do not have the ability to use “control rate” or “k-rate” signals.

Objects in Axoloti are defined in XML, containing the definition of inputs, outputs, parameters, selectable compile-time constants, and the relevant C-code.

Axoloti uses a compiler to generate efficient code, enabling inter-object optimizations and eliminating function-call overhead.

Why didn’t you just port Pure Data to a microcontroller?

Pure Data is not made to run efficiently on a microcontroller. The function call overhead imposed by dynamic linking is quite dramatic compared to the actual work in a function.

Tannhauser compiles Pure Data patches to efficient binary code for embedded devices. But it cuts the user-workflow in steps: designing a “simulation” patch in regular pure data (using a subset of objects and features), and then using Tannhauser to compile the patch. And then using another tool to upload the binary to your device. And then test. Once this starts to involve more than just audio input and output, the “simulation” patch running in Pure Data can’t represent the target anymore.

Axoloti integrates all steps, and allows to tweak and monitor signals on PC while your patch is running on the device.

Can I use Max/GEN or Faust DSP to generate Axoloti objects?

Maybe sometime in the future.

How does it compare to PatchBlocks?

Axoloti has hifi stereo sound I/O, more processing power, more memory, microSD-card for storing patches, samples and recordings. Axoloti has analog inputs, digital inputs and digital outputs free for user applications.

PatchBlocks also has a visual patch editor, no coding skills are required. But the Axoloti patcher allows to tune parameters, and display values or levels or waveforms interactively. The Axoloti patcher also lets you map parameters in your patch to MIDI controllers.

How does it compare to the Teensy Audio Library?

The Teensy Audio Library is intended to integrate with the Arduino programming environment.  While a primitive visual patcher is provided, it scope is limited to only defining the audio objects and connections, which are exported as C++ code to Arduino.  Any real-time control, MIDI, or anything beyond the simple interconnection of audio objects needs to be expressed in C++ by the user.

With Axoloti, you don’t need to deal with any code, though you can easily add C++ in your patch through a “script” object if you want to.

The Teensy3.1 has the same CPU core architecture, but less than half the CPU speed and memory of Axoloti.

The Teensy Audio Library standardizes on 16bit audio resolution and 128 sample buffer size. Axoloti uses 32bit and 16 samples buffer size for a high quality experience.

How does it compare to the Hoxton OWL?

A similar CPU is used. Their software is limited to configuring two effects, not anything near the power and flexibility of Axoloti.

How does it compare to Nord Modular/G2?

I loved both the Nord Mod and the Nord G2. But the closed environment limited me in expressing my own ideas. For example, non-equal-temperament tuning, or grooves were awkward to patch. Both synths lack the ability to use any sort of data storage in a patch. And no clean way to integrate it physically into custom instruments.

Internally, the Nord Mod and the G2 use 56K DSP chips for the audio work and those have very limited internal memory (24kB), and their architecture is not well suited for general purpose work, so they use another processor for coordination. The microcontroller in Axoloti is better suited for a mixed workload. Its large (1MB) on-board flash memory offers a lot of room for look-up-tables, or even a small sample set.

Can it emulate vintage synths/effects?

No efforts are done to create truthful simulations of vintage gear yet. First priority is brick and mortar functionality. I do value good practice in DSP. For instance the sawtooth oscillator is bandwidth-limited rather than a time-domain ramp. And the filter sounds sweet.

Oh and if all vintage equipment had been compared to truthful simulations of their precedents, they ‘d have failed. “Sorry this ARP does not sound like a real string instrument.”

There’s already many open source hardware synths, most of them with only few users and declining interest.

Most of those are based on much weaker microcontrollers than Axoloti, resulting in far less sonic freedom. None of them has an editor like Axoloti. With Axoloti I want to unite accessibility, playability, and hackability.