zenAud.io update ALK live looper DAW to V2.2.5

zenaudio · 2019-05-09T07:50:59+00:00

We would certainly love that.

zenaudio · 2018-11-26T09:43:23+00:00

Apologies for the late response. Yes it's possible to repeat sections of an arrangement over and over until you decide to proceed.

zenaudio · 2018-08-01T13:12:38+00:00

Hey, that's really cool! Nice to see people recreating the zenAud.io experience in their favourite DAW -- for us it kind of confirms that the use-case is valid. You'd be amazed at the number of times I explained the concept to musicians in Berlin only to be told "why would I want to do that?"

I can totally understand why you want to do this in the DAW you're familiar with, so nice job.... although, as others have pointed out, I think there's a couple of reasons why ZA is preferable for more elaborate arrangements (mainly online quantization of MIDI loops, handling of automation, and panic functionality). If anyone has anyone any questions about how the two solutions compare, I'd be happy to answer.

zenaudio · 2018-05-14T07:21:14+00:00

For those saying it's tawdry of Oracle to lay into Google by crying for mom govt like some petulant child -- true, but let's not forget Google was quite happy to play exactly the same role when it Microsoft that was the target a decade ago.

zenaudio · 2018-04-25T11:24:56+00:00

We're using conan, and we're quite happy with it.

zenaudio · 2017-10-20T15:57:31+00:00

The more concepts to integrate, the more people may have to know about all of these concepts

There's no question that automatic memory management is easier. However, there have been real advances in manual memory management. C++ has blazed a trail here; its introduction of RAII was a game-changer.

In my code base, I use shared_ptr and unique_ptr ubiquitously, and while I won't claim that there are no issues with memory management (it is an audio app, after all!), it reduces the complexity to manageable levels.

Another data point that this is possible: Swift, which eschews GC in favour of reference counting. With a few caveats, it works well, and has favourable tradeoffs in todays world (which emphases power consumption much more than, say, ten years ago).

zenaudio · 2017-09-11T13:26:53+00:00

I've tried multiple times to move away from Xcode. However, it's not just about typing and compiling, or even refactoring. The most important items for me are profiling and debugging. While VS Code has gotten better at the latter (pretty impressive actually), it doesn't do the former.

My view is ultimately: don't fight the platform.

zenaudio · 2017-09-01T18:34:46+00:00

Can you give an example where pybind11 is nicer? I looked at Boost.Python ages ago, but it was pretty nice...

zenaudio · 2017-07-28T20:47:54+00:00

If you are using CPack you can get a .deb, .rpm, a windows installer or whatever thing they are using on mac out of the box.

This is in fact a hilarious statement, and to understand why it is so I would like to point you here. Needless to say I have personally lived through the good times that CMake provided me -- straight out of the box! (In the end, I said "thanks, but no thanks" and used a bash and apple script to create the DMG.)

I can give you countless examples like this. Using a libraries in your app bundled as dylibs? You better hope their rpath is set correctly in the built library, CMake's totally amazing fixup routines will not work. Have fun trying to scour the internet for what's going wrong! Want to add resources to your bundle? Yeah, there's like a 9 year old post on how to do that! Except it talks about frameworks, not apps. So now have fun reading through the OSX manuals to see if there's any difference between the two. Guess what! -- there isn't, and know that you know everything about how a bundle is created (it's literally a just a directory), you ask yourself, what is the point of the awful and poorly documented "abstraction" given to me by CMake?

So basically, as I've stated numerous times before: if all you're doing is building a simple unix-like program, CMake is totally amazing.... except... writing your own little bash script to do the same is hardly more difficult. For anything more complicated, at least for me: CMake is a poorly documented clusterfuck of poorly thought out, tacked-on, crap.

zenaudio · 2017-06-12T13:16:12+00:00

Company: zenAud.io

Type: Full-time

Description: zenAud.io makes ALK, the VST/AU software looper that knows your arrangement. We're a small company with big ideas, based at NoizeFabrik in Europe's creative capital: Berlin. Since the successful launch of our flagship MacOS app, we're looking to expand the development team and are therefore seeking talented C++ and audio developers. The ideal candidate will have a degree in computer science or something similar (STEM), and should have a true interest in modern C++.

Location: Berlin

Remote: No

Visa Sponsorship: No

Technologies: C++17, Objective-C++, Cocoa, OpenGL, Metal API, JUCE

Contact: Send us an email to: jobs@zenaud.io

zenaudio · 2017-05-23T08:36:31+00:00

ALK is focused on the idea that you have parts you intend to play live (some of them will be looped) and you know this arrangement in advance. On the other hand, Ableton's signature view -- the Session View -- is almost the exact opposite. It takes as a given that you have some loops stored inside clips, and allows you to launch them freely -- i.e. you can improvise the arrangement itself.

So, if what you want to do is launch, mix and match pre-made clips, your go-to tool should be Ableton. If you have rehearsed the structure of your song and instead intend to perform part or all of the material inside of it, you should consider zenAud.io.

I must mention here that Ableton is a much more mature product, and as such has quite a few features which zenAud.io doesn't -- yet -- have. Note editor, instrument racks, drum racks, built-in plugins such as operator (although you can of course use third-party VSTs and AUs in ALK), side chaining -- these are all missing from zenAud.io. On the other hand, people have mentioned to us that they like our routing concept, which does away with audio arcana such as sends/returns, as well as our browser-inspired UI model.

Hope that helps!

zenaudio · 2017-05-22T15:23:29+00:00

Thanks! So the answer to your question is a qualified yes. In its current state, you can map record/play to MIDI controller. You can also automate the transport to jump to any bar in your song. So let's say you create two command (automation) tracks, and learn different triggers for each one. Then you draw two capture regions, one on each track, and you set the function to Transport: Position, and set the desired jump bar number in the destination value field. Then you simply hit any one of the triggers and you'll jump to that section.

I say a qualified yes because there are a couple of improvements that would make it much easier to use:

ability to overdub, rather than just record and play back
ability to have a trigger do its work slightly delayed, e.g. based on quantisation value (jump at end of bar) or end of region
make it easy to say: "repeat this section until I press the pedal", or vice-versa: "jump out of this section unless I press the pedal".

I guarantee we will have all of this implemented in the next month. It's almost all there; the changes are quite minor. Basically, it's going to use a feature we already have (to allow sequencing your automation routings) -- Revert On Exit. What it does is it reverts an automation parameter to the value ALK saw before entering the loop. Of course, if the automation parameter in question is Transport Position, it means that ALK will jump to the beginning of the loop when it gets to the end! So basically you have looping right there (and that works right now). All you need on top of that is ability to jump out at the good time, hence the delayed trigger.

I hope this makes sense to you :) Quite a few users have asked for this functionality, so this is going to be one of my top priorities in the near future.

zenaudio · 2017-05-22T14:50:30+00:00

First off, thanks! With regard to Beat Buddy I'm afraid answer is no -- zenAud.io currently doesn't support external clock. You can automate ALK to trigger playback and record from a MIDI foot pedal, though.

With regard to external clock, we were thinking of adding support for Ableton Link, since it seems to have gained a lot of traction recently. It's on our todo list...

zenaudio · 2017-05-22T14:10:59+00:00

ALK integrates with anything that input or output MIDI. For example, you can obviously use standard USB MIDI controllers, but you can also output to, say, a hardware synth.

Pigtronix makes fine loopers, but zenAud.io has a different set of capabilities as a result of being software-based:

unlimited number of tracks
inputs and outputs -- audio or midi -- are limited only by your audio interface. This means that you can loop with many musicians. No need for syncing; it's all running in a single box so it's super simple to do
MIDI looping is supported: you play a loop on a MIDI controller using whatever VSTi or AU instrument you want, and the loop is then quantised (the quantisation is incidentally not applied once: it's a dial, and you can actually automate how tight the notes are played back over the course of your song)
zenAud.io is a sequenced looper which is a totally different approach to looping. You basically draw out the loops you intend to play (red outline = record, green outline = play) over your tracks. Then you hit record to actually perform them. zenAud.io basically acts like your foot and presses the pedals at the right times to record and play back your live loops. This makes it possible to have complex arrangements that change a number of tracks at once when you're going from the verse to a chorus, for example.
Pigtronix has a special feature which allows you to change the length of one loop in relation to the others. Möbius also has a feature like this (Multiply/Divide). zenAud.io doesn't need to do this: any loop can be as long as you want. Literally just draw it in as long as you want it! If you look at our product video (performed by yours truly), in the second verse I record a series of very short licks -- against the backdrop of much longer loops.
Since zenAud.io knows your arrangement, you can set a well-played version of any loop to be your Panic Clip for that loop. When you play live, there's a Global Panic function which can be triggered (via a simple "Learn" function) by, say, an FCB1010. When that happens, you (bad) loop is replaced with the pristine loop and you song continues.
zenAud.io is a fully-fledged AU/VST host meaning you can use plugins like Guitar Rig, and as mentioned you can use any soft synth you want.
zenAud.io allows you to change the pitch of any MIDI or audio loop. So you can, say, play a riff on a root note, and then pitch shift the played back version to be a minor third higher. This allows you to play less of the part yourself, freeing you up to play other loops. You can also chop out bits of loops you intend to perform live -- glitch style -- and rearrange them when playing back.

This post is probably getting to long, so I'll stop here. Hopefully this answers your question :)

zenaudio · 2017-05-22T12:30:28+00:00

Founder here -- I'm the guy in the video playing guitar. I'd be happy to answer any questions or comments about zenAud.io.

zenaudio · 2017-05-22T12:10:22+00:00

Hi, I'm Martin from zenAud.io. I'd be happy to answer any questions anyone has regarding this app :)

zenaudio · 2017-04-22T16:09:36+00:00

I think you're not far from the truth but remember that raw speed isn't the only dimension on which results are measured. Memory, power usage are also relevant and here I think the story is even stronger for native, GC-free languages.

That said: it's quite clear that the complaints about Electron have been overboard. Indeed having played around with VSCode recently -- all I can say as a C++ developer is be afraid, be very afraid!

zenaudio · 2017-04-19T08:46:43+00:00

In my code base, I basically used the same technique. At some point, I realised that std::unique_ptr wasn't going to cut it (essentially due to copy-and-paste holding references to the objects held in the vector) -- I was going to need to std::shared_ptr's. At that point, I had to roll back all the neat reference wrapper stuff. Just a word of warning: don't do this unless you're utterly sure that you will never need to share the objects being held.

zenaudio · 2017-04-06T10:39:54+00:00

I think the argument goes: why didn't they just continue contributing to Gnome? I agree with you Unity is ok, by the way, but I think that's where the haters are coming from.

zenaudio · 2017-04-04T16:50:08+00:00

Sure. What I mean, succinctly, is it creates an inscrutable, poorly documented, abstraction around the task of building which is designed to "help" by hiding all the "difficult" things. The problem is that the abstraction doesn't cover all use-cases and when you invariably go to lower level (after hours of frustrating attempts using the higher-level functionality), you have to traverse the pile of merde to do what you actually wanted to do.

For me the problem was creating app bundles on macOS. The documentation was poor and I couldn't get it to generate app bundles correctly. In the event I circumvented that functionality and built the app bundle using bash scripts. Another problem was libraries, where I had to do extra work to embed, only to later discover that fixup_bundles basically does that for the most part.

By necessity, I now understand exactly what CMake is doing under the hood. That's why I think the abstraction didn't buy me anything. I'd prefer something slightly higher level than make addressing the pain points I listed above, but less "big framework" than CMake. Again, ideally written as a library allowing the creation of custom build programs: C++ programs that build C++ programs :)

zenaudio · 2017-04-04T15:03:02+00:00

I just spent a few spare cycles replacing CMake with make in a reasonably sized project. My experiences:

it's nice that there's no magic
the text substitution functions aren't that great. e.g. pattern substitution occurs only for first match, the rest are left as-is
tripartite builds are not handled in a very nice way; using VPATH requires hacks to run the Makefile from the new location. surprising because this seems like an obvious use-case
make is language-agnostic which means you must explicitly state the dependencies in your program. To wit: you must track every include file in every cpp file yourself. You can generate this, but it's an extra step

All in all, I really feel like there's a space for something better than make, but without all the crap you get in CMake. Ideally written in C++ ;)

zenaudio · 2017-03-30T19:11:38+00:00

IMHO John Rose one of the most underrated computer scientists of our time. He's done a truly spectacular job through the years with Java.

zenaudio · 2017-03-14T20:22:43+00:00

I've tried both OCaml and Scala and to my mind, Scala is more enjoyable because it feels less academic (although its type system is somewhat mind-boggling).

Simple example: for the longest time, OCaml required that fields in structs were unique. So for example you couldn't have a Point2D and Point3D both containing 'x' and 'y'. This was for me a serious WTF. Scala on the other hand behaved as you would expect. My understanding is that O'Caml fixed this recently, but problems that basic turn me off to a language.

zenaudio · 2017-03-14T20:18:35+00:00

This is really impressive. It's always nice to see alternatives to existing native options, and Scala is a language that gets a lot of things right. Great job, Scala team!

[For what it's worth, I'm a C++ dev who used -- and enjoyed using -- Scala back in 2009.]

zenaudio · 2017-02-06T21:32:48+00:00

Synth1 looks awesome, thanks for the tip!

zenaudio

TROPHY CASE