
Show HN: A realtime node-based audio synth based on LLVM - cpdt
https://github.com/monadgroup/axiom
======
cpdt
Hey friends!

This is a project I’ve been working on since the start of the year. We’ve just
released 0.4.0, so I figured now would be a nice time to start making it a bit
more public. There’s a bunch of interesting tech under the hood which I
thought you all would definitely be interested in :)

Axiom’s a project that grew out of my third try at building a realtime
software synthesizer for 64k intros in the demoscene. You can’t really fit an
mp3 file in an executable that small and expect for it to sound any good, so
instead we synthesize the audio and play it in realtime. A few other groups
have written synthesizers for 4k and 64k productions, however I built this for
two reasons: I wanted to make one myself, and I wanted to try some interesting
things with combining node graphs and basic scripting. At some point, however,
I realized that this could actually be a really useful tool for any musician
to have, since it really flips things on its head and allows much more control
than just stringing together a bunch of plugins (the question is, of course,
do people who make music _want_ this control - I'm not sure on the answer
yet).

Technology-wise, Axiom compiles 'node surfaces' with LLVM (no interpreters
here, the code has to run comfortably 44100 times per second!). The editor,
written in C++ with Qt, builds a MIR and passes it into the compiler, written
in Rust. This was my first large project in C++ and first project in Rust...
ultimately I think the Rust learning curve has definitely been worth it, as
it's by far the stablest part of the program!

Ultimately I’m hoping to somehow be able to turn this into a real product,
possibly by offering what you see as the core open-source software and then
building on it, into something like a DAW or plugin for procedural audio in
game engines (which a few people have suggested to me, and I think would be a
really cool application of the technology!).

Check it out, let me know what you think (either here, or shoot me an email,
chat on twitter, etc), ask questions, build something cool, have fun!

~~~
gmueckl
I suppose that you are familiar wuth analog modular synthesizers. There is a
demand for these, even though they become very expensive toys fast. But
musicians seem to like the flexibility and room for experiments that they
allow. Even software simulations of these synths are pretty successful. VCV
Rack ([http://www.vcvrack.com](http://www.vcvrack.com)) is a recent open
source emulation of eurorack synthesizers that has found a following fast.

If you are interested in providing procedural audio for games, you should take
a quick look at what WWise provides in that area. I have not had time to do
that myself, but from what I have seen it provides a lot of features for
controlling sound and music based on the current game situation. It is also a
pretty expensive package.

Edit: corrected link. Thank you striking!

~~~
striking
(the link is actually [https://www.vcvrack.com](https://www.vcvrack.com))

------
EamonnMR
The VSTi support is pretty sweet-it pretty much changes this sort of thing
from toy to tool.

------
w0utert
Awesome, I've always wanted to make something like this myself but never came
around to do it!

It would be really neat if someone combined this with a very simple
sequencer/tracker to create and manipulate tunes, which could then be dropped
in (sequencer + synthesizer) directly into projects. It could be a quick and
easy way to add music to small-scale retro game projects, for example.

------
caffed
Looks really cool, and similar to Audulus
[http://audulus.com/](http://audulus.com/)

~~~
cpdt
Yes, this was one of the initial inspirations for the design of Axiom! I never
actually had the chance to play with it though... would be quite interested in
learning how it works.

------
detaro
Looks cool, looking forward to playing around with it!

If it is compiling, can it also export code/libraries that can be embedded in
other projects, or is the way to go to embed the entire thing? Since you
mention demos as a target group I'd guess the first, but it isn't entirely
clear.

~~~
cpdt
Yep, that was one of the original ideas with using LLVM. The actual runtime
that's needed is pretty small and the code optimizes well, so the output ends
up being very close to if you'd written the code in, say C++, yourself.

But that said, I haven't actually gotten to writing the 'exporter' yet (up to
this point I've mostly been focused on usability and stability), so I can
understand that it's not entirely clear.

------
tyleo
Overall looks pretty neat. I’m a big fan of dark themes, but I think this one
takes it a bit too far. I’m having trouble reading the text which doesn’t
contrast well against the background. Consider lightening some of the
elements.

~~~
cpdt
Yeah, you're not wrong that it's pretty dark. I have done a bit of work
recently on lightening up (it was even darker before!), but I'll definitely
look at brightening it further in the near future.

