Home KXStudio > News

KXStudio : News

> Carla 2.1 RC1 is here!
On 2020-01-19 by falkTX

Hello again everyone, it is release day! (kinda, just a casual 4 days late...)

This is the announcement of the first release candidate of Carla 2.1.
I am skipping the beta phase as done for the 2.0 release and going straight into a Release Candidate.
This means there will be no more changes in the graphical user interface or engine/backend features, except when required for fixing bugs.

Carla projects/sessions are meant to be fully compatible between between 2.0 and 2.1 versions, except for features marked experimental.
The "native" API to access carla as plugin (as used by LMMS) is ABI and API-wise backwards compatible compatible with 2.0.
If this is not the case, consider it a bug that needs to be fixed.

As with the v2.0 release, the list of changes is a little big, so let's split it by parts.
First, the highlights and major changes, in no particular order of relevance.


Better CV Support

CV ports are now supported in the internal patchbay mode, meaning you do not need to use JACK with Carla in order to use CV plugins.

Automable parameters can now be exposed as a CV port, so they can be controlled by regular CV sources or other plugins.
This is a kinda feature preview, as there are some limitations at the moment:

  • Parameter changes are not sample accurate
    (in a later version, Carla will split buffer up to 32 frames for more fine-grained control changes)
  • Not all plugin formats and parameter types are allowed to be controlled this way
    (to be extended as I test more compatibility)
  • Only available for parameter inputs, not outputs

In order to make CV more useful by default, a new internal "MIDI to CV" plugin was added, originally created by Bram Giesen.
More plugins will be added as needed, for now I recommend to use ams-lv2 and mod-cv-plugins as they already do a lot.

Also, a new variant of Carla as plugin was created that provides audio, MIDI and 5 CV ports (for each side).
This allows CV signals to flow in and out of Carla as a plugin.


High-DPI support (work in progress)

Initial work was done to support high-DPI screens.
Note that this was not tested very extensively, due to lack of proper hardware, but the requirements in terms of code are all there.
There are still a few "normal" resolution bitmaps in use, to be replaced in future releases.
You can click on the screenshot on the left to see Carla rendered at 3x the resolution.

So for now, the situation is:

  • Most of the icons changed to scalable format
  • UI will scale with the desktop automatically, as Qt takes care of that for us
  • Some bitmaps still remain, to be replaced by vector images in a future release
  • Not extensively tested, feedback is welcome


Proper theme and Carla-Control for Windows

The Windows build stack changed from using official Python and PyQt5 packages to msys ones, allowing us to link against them using mingw (Carla does not support MSVC)
This makes it possible to use the proper "pro" theme like Linux and macOS already did, and also get Carla-Control finally working on Windows.

Previously, the Carla Windows builds were using Qt's "fusion" theme (which the Carla "pro" theme is based on), which looks very similar but misses all of custom tweaks made for Carla.
This includes, for example, preventing pop-up menus from taking the entire screen or ugly thick lines being drawn where a small one was expected.

A small but important step towards cross-platform feature parity. \o/


VST2 plugin for macOS and Windows, plus exposed parameters

This is the final item that was missing for cross-platform feature parity.
We now have Carla as VST2 plugin running on both macOS and Windows!

Embedding of the full GUI on these systems is not possible, so a small "middleware" window is shown as the plugin custom UI.
Not the best experience, but allows Carla to finally work as VST2.

Additionally, 100 parameters are exposed to the host, dynamically used in the order of the plugins loaded.
So for example, if the first plugin in the rack has 20 parameters, the first 20 parameters of carla-vst will be mapped to that plugin.
This continues in order for the remaining plugin parameters until we reach 100 of them.

When Carla is loaded as an internal plugin, parameters will be dynamically available too.
This feature is not available in the LV2 version of Carla though, at least not yet.

Note: Carla plugins are not "notarized" yet, so they will not run under latest macOS 10.15/Catalina where this is a requirement.


Wine-native bridge, sorta experimental

This is a way to load Linux binaries under Windows applications running with Wine, in case you need that for some reason
Personally I made it so that I could run the native Carla inside FL Studio, which allows me to use its sequencer but not have to deal with Windows plugins.

This is available in the KXStudio repositories as "carla-vst-wine" package, you need to copy /usr/lib/winvst/Carla* into your Wine VST dll folder to make it work.
It requires Carla to be installed system-wide, so it cannot work if Carla is downloaded manually.

Building it is kinda tricky, as it requires building a native-windows dll first, and then a few things with winegcc...
Packager documentation will be added soon to Carla's source code repository, so other Linux distributions can pick it up.

I demoed this feature at Sonoj last year (2019), you can watch it as the 3rd part of this video.


Refreshed add-plugin dialog and favorite plugins

The add-plugin dialog had a major overhaul, now looking much better and with more content visible at once.
Target was to improve the user experience, making clear that there are filters available. (it was not so obvious in previous versions)

The star on the most-left section of the table is to mark a plugin as a favorite, which will add it as a shortcut to the right-click menus on empty rack and patchbay areas.


Single-page and grouped plugin parameters

The dialog for the generic plugin parameter view also had an update.
All parameters are now placed in the same tab (separated only by input and output types), and grouped when supported by the plugin.
The options for mapping a parameter to a MIDI CC were taken out and replaced by a button that triggers a menu with the relevant options.

Note that, at the moment, only a few LV2 plugins support parameter groups.
This is because most hosts do not support this feature, so plugins do not have many incentives to support such a thing.
And with not a lot of plugins supporting it, hosts also do not care that much. The usual circular dependency deal...
But since the feature applies quite nicely to Carla, made sense to add it.

The group can be collapsed by clicking on it.

A similar feature will be added to the patchbay in a later release, so we can group audio ports too. :)

More UI changes

The rack items will dynamically show as many knobs as possible
You can now change the "skin" and color of any rack item, making it easy to identify certain plugins
Added buffer-size, sample-rate and xrun information to the status; clicking on the xrun counter will reset it to zero

Canvas changes

Right-clicking on a canvas group will show options for quickly connecting all ports to another group
Many small tweaks and fixes, plus a few extra actions, as contributed by Nikita Zlobin (to be documented on the user manual)
Support for Ardour-style inline-displays, marked experimental in this release (sadly cannot be made stable until Carla v3.0)

Carla-control and OSC rework

Carla's OSC support has been reworked, now has its own dedicated page in the settings.
Carla-Control has been extended to support all non-local-dependent features of the main Carla (like patchbay management and transport controls).
This will be extended even further in future releases.

AU and VST3 support is back, by leveraging JUCE

Disabled during a previous 2.0 beta release, support for the JUCE library was removed and replaced by a heavily stripped-down version of it. (while it was still GPlv2 licensed)
The reasons for that decision still remain relevant, but in order to keep in mind with Carla's goals, I decided to add back JUCE support - but now completely optional.
It will always be possible to build Carla without JUCE, it is only used for extra hardware and plugin format support.
In fact, Linux builds by default do not use it, as there is no need for it.

Anyway, the published macOS and Windows Carla builds do use JUCE, which means Carla supports VST3 under macOS and Windows, and AU under macOS.
As a bonus, it is now possible to show the custom control panel of ASIO devices. :)

Worth noting is that JUCE does not support VST3 under Linux at this point, so neither does Carla even if you build it yourself with JUCE enabled.

Other changes

Within a bunch of small fixes and new implementations, here are some changes that deserve to be mentioned:

  • Carla now requires Qt5, can no longer work with Qt4; but can still use LV2 Qt4 UIs with its built-in bridges
  • NSM is now supported for JACK applications
  • Added a 16 MIDI port mode for JACK applications
  • Added "Cancelable actions" during project and plugin bridges load, so they will no longer time-out; instead the user has the option to cancel them at anytime
  • Initial support for LV2 parameter API
  • Initial support for LV2 file paths, assuming plugin has no custom UI (click on the show-gui button to open a file dialog)

Notes for developers and packagers

  • Linking against the JACK library directly is now possible by using `make JACKBRIDGE_DIRECT=true`, which allows for building Carla as an internal client

Notes for users

The code for scanning plugins had a little rework, again, making some internal data structures change.
Because of this, a full rescan of your plugins is needed after the update.


To download Carla binaries or source code, jump on over to the KXStudio downloads section.
If you're using the KXStudio repositories, you can simply install "carla-git" (plus "carla-lv2" and "carla-vst" if you're so inclined).
Bug reports and feature requests are welcome! Jump on over to the Carla's Github project page for those.

Future and final notes

I have started a change of the Carla's frontend coding language, from Python to C++ (for performance, reliability and debugging reasons).
There are a few canvas related things, currently experimental, that can never be made stable or fast due to how Python/PyQt works.
Also Carla is not scaling very well at the moment, and the addition of CV controlled parameters and inline-displays does not help its case.
So a move of the entire frontend to C++ makes quite a lot of sense.
Whenever this is finished a new release will be made.
But it is going to be something that, even though means a lot behind the scenes, visibly nothing will change. (except performance)
Because of this, do not expect many UI related changes in Carla for the time being.

A user manual for Carla has been started.
It proved to be quite helpful for development too, as I had to justify why things are the way they are, and explain how they work too.
Now that Carla UI should not change too much for a while, it is the right time for such thing.
I personally dislike writing such things, but understand it can be quite useful.
The work-in-progress manual is at https://kx.studio/Documentation:Manual:Carla.
(Not much to see there at the moment though, give me time)

That's it.
Please remember that this is a release candidate, and not the final release.
Some issues are expected, I will do my best to fix all reports that get to me.
If I don't know about the issues though, I can't fix them. So please report any issues you find, thanks!