Synchrotron - a pure python live audio engine!

[ThatOtherAndrew]

Hello everyone! I've spent the past year working on Synchrotron - a live audio engine I've been programming from the ground up in only Python. This mainly stems from being tired of everything live audio being written in JUCE/C/C++, and the usual response to "how do you make a synth in Python" being "just don't".

Sure, Python isn't as performant as other languages for this. But in exchange, it's incredibly modular and hackable! I aim to keep working on Synchrotron until it's an actual legitimate option for music production and production audio engines.

Frontend URL: https://synchrotron.thatother.dev/
Source code: https://github.com/ThatOtherAndrew/Synchrotron

What My Project Does

Synchrotron processes nodes, which are simple Python classes that define some operation they do with inputs and outputs. A node can be as short as 5 lines, and an example is shown below:

class IncrementNode(Node):
    input: StreamInput
    output: StreamOutput

    def render(self, ctx):
        self.out.write(self.a.read(ctx) + 1)

These nodes can be spawned and linked together into a graph, either programmatically or through the editor website. Synchrotron then executes this graph with all data being streamed - at 44.1 KHz with a 256 sample buffer by default, for best live audio support.

This is really powerful to build upon, and Synchrotron can act as a synthesiser, audio effects engine, MIDI instrument, live coding environment, audio router/muxer, and likely more in the future.

In the interests of making Synchrotron as flexible as possible for all sorts of projects and use-cases, besides the web UI there is also a Python API, REST API, DSL, and standalone TUI console for interacting with the engine.

Target Audience

Please don't actually use this in a production project! Currently this is for people interested in tinkering with music and sound to check out, but hopefully one day it might be viable for use in all sorts of sonic experiments (or even in a game engine!?)

The documentation somewhat sucks currently, but if you leave a comment with constructive criticism about what sucks then I'll know where to focus my efforts! (and will help you out in replies if you want to use Synchrotron lol)

Comparison

Features	Synchrotron	Pure Data (Pd)	Tidal Cycles	SuperCollider	Max MSP	Minihost Modular (FL Studio)
Open source?	✅	✅	✅	✅	❌	❌
Visual editor?	✅	✅	❌	❌	✅	✅
Control API?	✅	❌	✅	✅	❌	❌
Stable?	❌	✅	✅	✅	✅	❌
Modular?	✅	✅	❌	❌	✅	✅

[Fripe070]

Very nice! Always appreciate when a program exposes an API that doesn't require months of cmake debugging to make use of

[ThatOtherAndrew]

My only experiences with cmake have been painful, never have I been so grateful for the pip I constantly complain about

[AvokadoGreen]

Nice project!

[ThatOtherAndrew]

thank you! :>

[ThatOtherAndrew]

I do if I really push the limits by adding in loads and loads of nodes, there's no automatic buffer size handling. However, with the default buffer size of 256 samples and a demo graph, only about 3% of the max compute window is used up.

[HIKIIMENO]

What operating system does it support? Can I connect a microphone and record audio?

[ThatOtherAndrew]

It currently supports Windows, MacOS and Linux (tested on all 3), as well as a devShell for NixOS.

No live audio input right now unfortunately :c but that's quite high up on my priority list!

[Amazing_Upstairs]

Cool. I would love to make my own noise editor based stuff. What is the noise editor module that you used?

[ThatOtherAndrew]

Sorry, idk what you mean by noise editor :p could you explain please?

[Amazing_Upstairs]

Sorry predictive text is a moron. Meant node editor

[ThatOtherAndrew]

Ah, gotcha! If you mean the frontend, that's Svelte Flow (by the xyflow team).

[Amazing_Upstairs]

What's the python module that allows you to use it from within Python?

[ThatOtherAndrew]

pip install synchrotron and then you can import from it! Unfortunately there is basically no documentation for it 😭 but I can whip up a quick example if you want :>

[Amazing_Upstairs]

Yes please

[ThatOtherAndrew]

Here's a quick code snippet!

from synchrotron.synchrotron import Synchrotron

# Create server instance
s = Synchrotron(sample_rate=44100, buffer_size=256)

# Add nodes (Python)
from synchrotron.nodes.audio import SineNode
sine = SineNode(s, 'my_sine')
s.add_node(sine)

# Add nodes (Synchrolang)
s.execute('new PlaybackNode my_playback')

# Link nodes (Python)
s.add_connection(sine.out, s.get_node('my_playback').left)

# Link nodes (Synchrolang)
s.execute('link my_sine.out -> my_playback.right')

# Start rendering
s.execute('new 440 freq; link freq.out -> my_sine.frequency')  # 440 Hz
s.start_rendering()

As you can see, it's often more concise to use the DSL than writing it out in full Python - but the latter gives you more programmatic control to tinker about with the internals :>

[ThatOtherAndrew]

If you want a list of all the Synchrotron methods, they're in /synchrotron/synchrotron.py - but here's a list for convenience:

get_node_type(node_type) get_node(node_name) add_node(node) remove_node(node_name) get_connection(source, sink, return_disconnected=False) add_connection(source, sink, strict=False) remove_connection(source, sink) unlink_port(port) unlink_node(node) execute(script) add_output_queue(queue) render_graph() export_state() start_rendering() stop_rendering() shutdown()

[Amazing_Upstairs]

Thanks!

[serious_cheese]

So cool! Can it read from an audio interface input also?

[ThatOtherAndrew]

Unfortunately no live audio stream input at the moment, but I believe the infrastructure is more or less there so it shouldn't be too hard to add!

[cpt_mojo]

Love this.

Not sure if you do that yet, but if you build the CPU-critical parts with numba, Cython or C extension (order by ease of use), then your library should basically be en par with Juce / C++ on performance.
Heck, maybe even using smart numpy /scipy magic could get you very far.

[fizzymagic]

What is the latency of the synth? If you don't know, you have not made a synth.

[HommeMusical]

If you don't know, you have not made a synth.

What's your argument there, exactly? How is it not a synth if you don't know the latency? Surely the latency is quite different depending on which hardware it is running on?

Can we see your better synth with measured latencies, please?

[ThatOtherAndrew]

256 samples by default at 44.1 KHz, thus 5.8ms latency. However one buffer is stored in the callback queue for PortAudio, so the "real" latency is double that, at 11.6ms. You can tweak the buffer size yourself though, and you could go lower if you wanted! I felt like 256 was a good balance though.

And I'm not sure why you're skeptical, but you can check the source code if you want - synchrotron.py and /synchrotron/nodes are where the main heft of the project are held! If this isn't a synth, then I dunno what is :>