Plugin Formats: An explanation of various formats and why they exist (and why they are all shitty)

Video thumbnail (Frame 0) Video thumbnail (Frame 1835) Video thumbnail (Frame 5140) Video thumbnail (Frame 10134) Video thumbnail (Frame 15864) Video thumbnail (Frame 18966) Video thumbnail (Frame 21841) Video thumbnail (Frame 26266) Video thumbnail (Frame 28098) Video thumbnail (Frame 39309) Video thumbnail (Frame 44777) Video thumbnail (Frame 48546) Video thumbnail (Frame 50599) Video thumbnail (Frame 53575) Video thumbnail (Frame 64368) Video thumbnail (Frame 67783) Video thumbnail (Frame 69746) Video thumbnail (Frame 74393) Video thumbnail (Frame 80498) Video thumbnail (Frame 87906)
Video in TIB AV-Portal: Plugin Formats: An explanation of various formats and why they exist (and why they are all shitty)

Formal Metadata

Title
Plugin Formats: An explanation of various formats and why they exist (and why they are all shitty)
Title of Series
Author
License
CC Attribution 4.0 International:
You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor.
Identifiers
Publisher
Release Date
2018
Language
English
Producer
Chaos Computer Club e.V.

Content Metadata

Subject Area
Point (geometry) Plug-in (computing) Different (Kate Ryan album) Digitizing Workstation <Musikinstrument> Right angle Bit Plug-in (computing)
Point (geometry) Plug-in (computing) Curve Programming language Standard deviation Open source Software developer Range (statistics) Bit Cartesian coordinate system Goodness of fit Software Plug-in (computing)
Plug-in (computing) Code Cross-platform Software developer GUI widget Sheaf (mathematics) Bit Shape (magazine) Code Computer programming Demoscene Goodness of fit Latent heat Algebra Personal digital assistant Order (biology) Software framework Computing platform Software testing Directed set Software testing Hacker (term) Plug-in (computing)
Standard deviation Building 1 (number) Frustration Product (business) Neuroinformatik Latent heat Crash (computing) Mathematics Bit rate Single-precision floating-point format Ideal (ethics) Software framework Plug-in (computing) Form (programming) Boolean algebra Multiplication Standard deviation Software developer Projective plane Bit Cartesian coordinate system Demoscene Data management Software Personal digital assistant Iteration Quicksort
Standard deviation Open source Computer file Code State of matter Patch (Unix) Multiplication sign MIDI 1 (number) Combinational logic Parameter (computer programming) Event horizon Goodness of fit Different (Kate Ryan album) Plug-in (computing) Boolean algebra Plug-in (computing) MIDI Standard deviation Multiplication Email Structural load Software developer Interface (computing) Keyboard shortcut Sound effect Parameter (computer programming) Bit Cartesian coordinate system System call Personal digital assistant Escape character
Plug-in (computing) Slide rule Standard deviation Interface (computing) MIDI Parameter (computer programming) Software testing Plug-in (computing)
Computer file Open source Code State of matter Multiplication sign MIDI Function (mathematics) Parameter (computer programming) Mereology Neuroinformatik Number Revision control Crash (computing) Latent heat Semiconductor memory Hacker (term) Single-precision floating-point format Intrusion detection system Plug-in (computing) Plug-in (computing) MIDI Default (computer science) Standard deviation Scaling (geometry) Software developer Structural load Binary code Sampling (statistics) Plastikkarte Sound effect Parameter (computer programming) Bit Multilateration Cartesian coordinate system Limit (category theory) Entire function Arithmetic mean Process (computing) Personal digital assistant Artistic rendering Volumenvisualisierung output Figurate number Musical ensemble Window Reverse engineering Library (computing)
Open source Computer file Execution unit MIDI Binary file Proper map Metadata Expected value Revision control Fiber bundle Directed set Aerodynamics Multiplication Plug-in (computing) Computing platform Computer architecture Plug-in (computing) Game controller Pairwise comparison Standard deviation Software developer Projective plane Parameter (computer programming) Algebra Window Reverse engineering
Dynamical system MIDI Function (mathematics) Mereology Neuroinformatik Latent heat Fiber bundle Intrusion detection system Aerodynamics Multiplication Plug-in (computing) Game controller MIDI Multiplication Remote administration Structural load Software developer Expression Electronic mailing list Sound effect 3 (number) Bit Cartesian coordinate system Graphical user interface output Fiber bundle Window
MIDI Game controller Standard deviation Observational study Open source Computer file Software developer GUI widget MIDI Algebra Personal digital assistant output Computer architecture
Keyboard shortcut State of matter Multiplication sign Execution unit Parameter (computer programming) Function (mathematics) Mereology Turtle graphics Graphical user interface Different (Kate Ryan album) Physical system Real number Software developer GUI widget Sampling (statistics) Data storage device Sound effect Parameter (computer programming) Bit Portable communications device Entire function Message passing Fluid statics Website output Point (geometry) Game controller Functional (mathematics) Computer file Real number MIDI Binary file Event horizon Metadata Revision control Goodness of fit Latent heat Intrusion detection system Authorization Integer output Maß <Mathematik> Plug-in (computing) Default (computer science) Default (computer science) MIDI Standard deviation Information Projective plane State of matter Cartesian coordinate system Limit (category theory) Graphical user interface Algebra Software Personal digital assistant Mixed reality Single sign-on
MIDI Identifiability Information Software developer Binary code 1 (number) Electronic mailing list Virtual machine Hidden Markov model Bit Turtle graphics Portable communications device Event horizon Metadata Neuroinformatik Number Revision control Crash (computing) Fluid statics Algebra Order (biology) Synchronization Plug-in (computing)
Slide rule Parsing Computer file State of matter Multiplication sign Decision theory Turtle graphics Perspective (visual) Metadata Portable communications device Neuroinformatik Latent heat Synchronization File system Error message Plug-in (computing) Boolean algebra Standard deviation Structural load Software developer Projective plane Sampling (statistics) Directory service Complete metric space Portable communications device Fluid statics Algebra Software Personal digital assistant Synchronization Single sign-on Summierbarkeit Figurate number Library (computing)
Presentation of a group Morphing Functional (mathematics) Computer file Open source State of matter Buckling Decision theory Multiplication sign MIDI Virtual machine Client (computing) Open set Turtle graphics Metadata Formal language Power (physics) Programmer (hardware) Goodness of fit Hacker (term) Synchronization Cuboid Energy level Plug-in (computing) Physical system MIDI Multiplication Standard deviation Email Matching (graph theory) Information Software developer Structural load Projective plane Binary code Bit Cartesian coordinate system Category of being Uniform resource locator Process (computing) Befehlsprozessor Algebra Personal digital assistant Buffer solution Synchronization Window Reverse engineering
all right
of my name is Philip you community I want to talk about plugins why they exist differences between them a little bit it's going to be more of a technical talk and so if you want at any time please raise your hand if you have any questions the intention is to make sure you understand the talk rather than me just saying things and so any question just let me know and if it's a short one you can just raise your hands I'll point to you you can say it and I'll repeat it to the microphone and otherwise hopefully if someone brings the microphone to you if it's something a bit longer and I assume that people here know what the digital work audio workstation is or a plug-in host and actually what the plugin is hopefully with this we can continue and why am I doing this myself I mean I think users
get a lot confused because we have so many plug-in standards it might it gets a bit confusing and not sure exactly what to use what are the best things good things about each other and I did myself a plugin host and also developed some a few plugins in the range of formats so I I know a little bit of the topic and I have to start with some
small disclaimers the first is a bit controversial but I want to put it to say it right away that open-source software by itself does not really need plugins because everything is open we can make an application we can compile everything statically if someone makes a plug-in we can copy inside their own application and that's it I mean the most point of making plugins is to load external things that are not ready when we ship or application a mostly regarding commercial software it's a bit tricky there are good things bad things about plugins but we do need it right now because in the real world we want to use commercial plugins if everything was open source will not need it but it's not the case and and also making good plugins is really really hard and there's a small there's a three-shot first if you want to do a plugin you have to be a developer you have to know a little bit about the programming language that are using the that your clothing the plugging in but after this if you follow some examples is usually simple the thing is there's a lot of work behind these things to actually make something nice and something that works really well and well we have to keep that in mind like that it starts with a little how they say it the curve goes quite a lot goes
up quite a lot initially because you have to know some programming it is quite technical then you can follow some basic programming copying code actually yeah you can use pre-made
pre-made things watch some tutorials everything is good act like copy and paste encoded people ready-made some filters and hack it together try it out I actually heard some developers actually saying this working harder that's good for me it's good shape it and I mean that's not easy that's not a good thing for them for the community in general sometimes because if you have a plugin that works in a specific application but you've never actually bothered to try in another host it didn't actually make and now the plug-in per se you made another plugin for other in this case so it's it's another plugin that works in order but you don't really know if it works in somewhere else or not so but anyway the hard way is it requires a lot more you should like usually developers investigates the plug-in formats that are available so they don't start coding right away and then make a mistake to realize the specific format requires specific things then you have to restructure in your entire codes and it becomes a mess so there's a lot of stuff behind the scenes usually developers do their own little framework and their own little mini UI toolkit and this is because if you want to make plug-in - you often end up reusing a lot of things it's good to have tools that work for you as best as possible like the good plugins that I know usually go for something like this you test cross-platform because you work want to have as many users as possible you do a proper build some actual commercial plugins don't actually care for this I don't know why and you if you are a good developer you go along and try to update according to the specifications sometimes specifications change if you don't follow along you looking gets unusable but this is the case we have kind of right now there that's a bit more only on the left side I have the plugins that were put in formats that currently work on Linux there's a few more but it mostly internal things on the right side we have stuff does not directly work on Linux so I'm focusing on this talk regarding this section here if these two are separate I'll explain soon why do I have so many people concerned that's actually so many plug-in formats one of the reasons is that developers are typically stubborn
and very I I can say for myself I am a little bit as well and like when you do a product in a company if when you have a fight usually the project manager started sorts it out for you but when you're making a plug-in format you're actually making something that is open something that is going to be used by other people so there's a lot of consideration you cannot just is not an internal thing is some you have to make sure it works well otherwise people just complain me and neither format you just useless you'll have to redo it again and people complain even more because now you have two standards it's let's see let's see there's different targets as well so one plug-in format that works well for let's say kinda in the network setup we have multiple computers everything with the target of rendering complex pieces might well not be the same target as some some embedded device for example that only wants to play one instrument so in this case you might use different formats and not one that tries to do everything because if you try to do everything at once may not work so well there's always something missing went into a format that's I mean you cannot predict the future so you might do a form and say everything is nice we support all cases and then comes along when new things like I forgot to support this thing we have to make something new and then you have another format yeah there's sometimes there's the case of not implemented here syndrome that's actually a name in the case that when you make an application you often because you have to support a bunch of things what usually happens is that you either you convert for example if your application is mostly about supporting vsts whatever other formats you support you kind of convert them behind the scenes into a VST and then load the plugin or you try to have your own internal format inside the application then then maps into other existing formats so it kind of few cases applications end up having their own internal format and because you spend so long working on this you kind of start to believe that your format is actually better than the others in a way I mean it works for every single use case that you know of of course if it won't crash so you start thinking maybe my internal thing that ideal for my application actually would work as an actual plug-in format and then you release it and then been another boolean format there it is it happens sometimes I mean for my own application my own plug-in hosts there's an internal thing for my own boolean framework vpf there's an internal API as well because you always have to follow on most of the frameworks that you use to facilitate building multiple plugins at once have their own internal thing because that's just how it is unless you code in a specific format for example we have to visit one on two and then you have to convert but you always lose something there's always a bet rate of in this cases I there's also one note
that nobody likes to handle plug-in formats except their own because they always think you know I did this the it can it handles all the cases it's probably quite it should be good for other people except I think this before talking to others I have the case sometimes of plug-in standards being so annoying like you when you try to develop a plug-in you investigate the specification everything it gets so irritated that is irritated with it then you start thinking screw this I actually do my own format because this thing is so insane so crazy no one shoe should be should need to handle this is insane and I actually saw one new formats and I actually tried to do it as well but then I I thought would make some sense as well but some formats came out of people just being frustrated with the existing ones and just think to themselves I can do better than this documentation sometimes is missing which helps in for this situation we know well v2 it's a bit tricky sometimes on this because there's it's a bit older now it's been going through several iterations some little changes the documentation no longer applies you people do get a little bit frustrated and you have the cases sometimes of developers that want to rush you want to release your plug-in as soon as possible so you end up doing something very nice but it does not actually followed specification completely I have cases like this where a plug-in cannot open its own UI in my own host but it works on others and the reason is that the developer
didn't bother to implement the plug-in properly so you add a little bit of hack here and there for specific plugins because otherwise the plugin is not loads if the plugin is not loads people will just blame you because it works fine in other hosts so it's your problem and for the open source things sometimes not really the case because you can fix it you can see the code can see what it is can send patches it helps a little bit for commercial things where do you even report tickets yeah yeah you have to send an email and hope they they care sometimes they don't maybe the company does not exist anymore and that's it you have to have workarounds everywhere as inside the calls just to support specific boolean sometimes the plugins also have workarounds to support specific hosts because they also sometimes don't follow the standard completely if the documentation is lacking people start interpreting the format's in misleading ways as well because I mean documentation is not clear you don't know exactly if you should do one way or the other we have multiple applications developers that think differently so you wind up with a standard but people just do things differently and never work in the same way which a bit said so making standards is quite hard not just for plugins but in general in the text you need to write regarding standards needs to be direct but also in a way that is understandable and there's always people that find nitpicky things Knuth it's complicated but yeah I want
to go through the differences of the of the formats that exist I'm going to start with VST which we can also call it 52 because it's the most famous one it actually started I don't know how long it is I'm not going through the history actually of the plugins themselves of the plugin specs because I don't think is we don't actually need this for this talk and most about what already exists today and what it can do what it cannot do in the case of ESC VST it got so popular because it was one of the first so people were like I can make plugins so I an application can be extendable in a way you probably know I mean if you don't I'll explain a little bit because it does can do audio effects can do MIDI as well MIDI being the events you send with the piano keyboard and the knobs as well can do the parameters although in a very weird way because all the values inside VST are normalized between zero one one so if you want to display the actual value of a plug-in you have to ask it like what is this 0.5 actually mean and then it says hey it's sustain off really okay yeah it's one thing that I don't know why they went through this maybe it makes it simpler in some cases it's probably because the application was programming this way so to make it easy for them this standard also follows it and it allows for presets which is combinations of parameters basically and the custom interfaces this was the thing that actually made it quite popular because now we have fancy UI is together with their plugin and people at least the ones that are not very technical they love device because they look so fancy so nice like you cannot make it plug-in anymore sadly if it doesn't have a good interface people usually kind of dismiss it and it also shows in a way that you care and you have some polish because you spend some time there's any good interface with it does not really mean if the plug-in is good or not just you had a designer or paid a designer and you did some work for you there's custom state as well which means it's not really parameters could be M a file that you loaded or even something that you draw or some something that are not always defined as parameters something that you can ultimate this was in the case of VSD there's more stuff regarding latency audio passes X or LD buses a lot of stuff but actually
there's a lot of bad things as well in the slides I'm not going to show the the
bad things because I don't want to focus too much on the on them but I do want to mention them because people should know like VST is a very old standard it was one of the first the fact that is VSD two is big I mean there's a reason for it because it used to be VST one the cool thing is that it actually keeps good and bad thing it keeps the old stuff that we have before so plugins made with quite a few years ago still work to the AES VST because the interface remains the same but it also means that there's a lot of stuff inside the standards I would say around 75% that it's completely and used by 99% of the plugins because you look at the documentation that's so much stuff going on there and you don't care most it was mostly a test I guess because they wanted to support almost everything but
in the end it ended up not being used much one bad thing about VST and most plug-in standards actually is that they are binaries which means if you want to know what what is inside this little binary you have inside your computer you actually have to load them first then you can figure out what the plug-in tells you this has the bad side effects that if if you love the a bad plug-in because developers sometimes are lazy we have I showed you that sometimes you go to the e-zpass and you make bad plugins and plugins can crash your application that's matter of fact we have a question already yeah that doesn't mean if you have a sample library like 16 gigabyte or so and you want to just ask what is this for plug-in does it have to load all the 16 gigabytes first no because that you unless it actually is are coded to have this in memory sometimes it does hopefully not but in this case this sample library would be some various loads after being out there being what was the first time you tell it to load the state and then it loads the entire thing the only problem would be imagining that this plug-in loads this huge library by default which means yes if you want to scan it it will take quite some time okay what some applications decided to do first was to start an external process to load the plug-in data so if the external process crashes it isn't crash your main application they also do the quick scanning which means they don't actually load the binary they just try to figure out what's inside and this is just hacks around because plugins the standard is not that nice and it was not thought in this case for VST another thing that got added in suspect that has not been used we have the VST XML which is actually metadata but it's not stored inside the binary but I have I have to see at least one host that implements this so far I didn't see a single plugin or host that actually uses this part of respect which would mean that the host don't have to the crash moon skinny like it's part of the specification but no one actually does it because it's not enforced another limitation is that it has one single MIDI port it's hard to describe exactly what it means but it you cannot have more than one mini input or more than one one MIDI output but that's a small invitation and the normalized parameters I explain you everything to zero to one although it's not just this spec it's not just VST other than other formats decided to do the same but on VST they have the bad case of if you're automating a parameter and then you want to know the what to display in case of a future thing that you're going to get like your parameter is zero now but in the future is going to be 0.7 you have to actually have to change the value of the plug-in to 0.7 ask and ask what's the value of this what it corresponds to and then change back to what the value was before which is quite nasty I saw some hosts doing something quite nice nice in a way that actually does the I think 100 steps of rendering of all the values then it tries to in a smart way figure out if it's something that like an on/off something that scales linearly logarithmically just based on those entire render stuff the values if a bit nasty but also a bit smart as well it shouldn't be needed and resizing windows in VST because sometimes you want to make the window bigger or smaller it's quite a pain really especially on windows there are so many hacks on this it's it got to really really insane that's the only thing I can say and the standard is the extensible when in a very ugly way and because not part of the actual standards you cannot really expect to have extensions in VST there's only one or two that are actually supported you can if you lo the plugin just expect it like extensions even if they are good to not be supported and all the bad things that the plugins are identified by a unique ID which is a number that's actually the specification says that to load the session you use this ID to identify the plug-in so you cannot have officially just hosts eventually figure out a way around it you cannot have the same version of the plug-in installed in two different places because they share the same ID and you have to register it in the website somewhere that you want this ID for you which most developers don't do so you end up with conflicting IDs quite a little bit sometimes so the hosts had to work around the thing not just saving the unique ID but saving the file path says in figuring out the way that it close your session correctly and license is quite the issue for VST especially in open source because it's not an open license which means if you make a plug-in using the official SDKs SDK the official VST SDK you cannot actually release the code in a GP in GPL which is the usual license which means [Music] it's conflicts with open source values anyway we have a free reverse engineered version of the VST which is not interesting which is the base bare-bones of what you can do which is enough to build plugins and to build hosts out of it but even this I mean the company that makes VST does not actually like people doing this and I'll get to that a bit later and it is a dining format now by its own company because V s there's now 53 so the company wants to kill this spec in fact after two more days actually what today
is 27 so you have three more days to register with Steinberg the company that
makes the standard to actually get a copy of the VST SDK in three more days if you register you're no longer allowed
to make VST two plugins that's because they don't want you to they want you to move to the new one so and even be a commercial company you don't get a say in this I mean you can try your luck and still do it that but then has it happened before they can send you a DMCA and try to bring your project down because they if their copyright in a way it's it's not nice anyway
53 the main issue myself that I have with this is that the name is completely misleading if there has nothing to do with VST - yeah you think it is but no the only thing that it has is the name and the company behind it and some small ideas of I mean it's a plug-in standard yeah but VST - and how for example could and these two comparisons other units or lv2 they're quite similar in the way that they're also completely different like don't don't expect a plugin that works in vsc-2 - suddenly in an update going to support VF III because no it's not how it works it's there's a lot of marketing behind VST 3 to try to make it a thing developers don't like it because now we have to support a new thing and the old one still works fine only the company that made it that wants everyone to upgrade and so it gets confusing is still a binary format so it means you have to load the thing the binary so it can crash your host and this also has the VST xml metadata which is stored outside of binary but as the expectance most hosts don't support this and license is a lot better than before you can actually make proper open-source plugins with the with VST 3 but now has become more than just a plug-in format they have an SDK so big in a way that you have to compile quite a lot of files just to get a basic plug-in working like it used to be that you have a single file as a reference for your for your base that's how the reverse engineer the GPL version got but now we then for the developers here via c3 is no longer as see a simple C API is a very complex very big C++ thing which might get into issues regarding compiling for win for Windows from the open source I I'm not sure have to tries to and it's very commercially oriented in the way that they don't care so much about open source like when Linux only has support via for VSD 3 since a few months ago because a contributor actually decided to help them to make the ac3 working here so if we want to make it work for other architectures or other platforms that are not Linux like BSD you actually have quite a some work to do first
because before it actually starts working there because it's more than an SDK I for personal reasons I find in the the specification to be quite ugly the way they use IDs to define every single thing every single objects and utf-16 that you're forced to use because it's the thing that they use in Windows I
guess tt f/16 yeah why I actually skipped the the things it does I've got but one thing that we se2 did was dynamic inputs or outputs but you had to do it when the plug-in loads initially with VST 3 dynamically can remove things and it's actually part of this pack in a better way that old one was I mean it's the documentation is a lot better they have the thing looks a lot better than before because they're learning some lessons I guess that might be a reason why they'd be wants everyone to move you have multi MIDI ports so you can have more than one MIDI input on more than one MIDI output not expression which means in each note that you play you can have the pitch can be modulated and panning and other a bunch of things that you can apply per notes not just in entirety effects or may sometimes you use MIDI channels but I put it in quotes because it's a lot of work to actually support on the plug-in size so just saying that the spec supports not expression does not mean much because most plugins will not have it if the port's remote control list which is about loading your UI your GUI in a different computer from where your actual host application is running on it's a big thing for LD to but V S III also has it single bundle is actually something I find quite nice at least for developers that want to ship just one single download this means that you can ship a V S III and have Windows Mac Linux there is a bit sixty sixty four-bit everything inside a single folder and
because they I mean this I find quite nice but I don't know how they define the architectures in this case and I mean I didn't study via Street too much in Linux we only have a single plug-in collection from the UAE developer that releases for VST three I mean it's very new to Linux and personally I hope it isn't to say too much because we have we have better stuff to own Linux to support like lv2 but offered VST and
commercial stuff and lots ba is the one that started in Linux can they have an open source VST but they wanted to make it as simple as possible this means it does audio it does not do MIDI and it has controls and input and outputs and that's it there's nothing else in the standards to do anything else you don't have like loading files customize anything I mean the entire thing is quite small it's one of the big things about it and one of the best things about it as well if you wanted to
support in an application is quite simple and that's why sometimes even new projects end up supporting lot span because you gain access to a bunch of functionality a bunch of balloons there already exists over the years and it is not really that hard to actually implement something like this and it's quite nice but you know the they're still the best things that it doesn't do much you can do audio effects cool it's also not for the bad things like it's also binary format so you have to load the plugins if you want to know information about them so it can crash your host as well yeah he asking before even loading plugin that's correct if the plugin is made in such a bad way that it crashes when it's first loaded because you have to load the plug-in to find out what it's inside you can basically crash the host to just by loading this little thing you put there then you have to find out which plug-in this question your entire thing and go there and delete it then hey I got my session again yeah you have the experience hey this copy one ugly thing from BST which is the unique ID which means for the host within defy watch what looking is inside he uses an integer which I don't know why they decided to go with this and you also have to reduce it to a website which no longer exists because there's no longer maintained so it if it's a bit ugly the way they'd the way they do the default values for the controls for the parameters is I find it quite ugly but it's one of one small thing it's not extensible so this is what you get I mean if you want simple stuff yeah you can have simple stuff yeah after the last point came all our
LDF I don't know how to say this it basically is RDF on top of Lata it's not actually a new plug-in format it just metadata on top of Lata it provides three things real default values instead of using complicated hints presets in an actual defined way so you can share it across applications and defines units for your parameters it needs literal I mean I mean maybe two hosts in the entire Linux application sweet supportive ardor supports this currently in the way sometimes and Jack Krak maybe and I don't think anything else this is RDF is quite ugly to look at to be honest but it they've also learned some lessons from this eventually but anyway moving on we have the SSI which is the one that came after last ba because developers wanted a little bit more than just controls the idea was to not reinvent what already exists so we got MIDI although only input not output based on the awesome API we got gooeys in this case using OSC for getting messages from the plugin to the GUI and some extra things like defining what is the default midi CC for each of the parameters you can now finally store data that is not just parameters although it works I actually like the standard the way they did this is also very a little bit limiting it as well and it defines presets but in this case only on the plug-in side not on the host side which can get a bit tricky because then you cannot you cannot do presets in a way that works on our applications because they're all going to do it in a different way it's not a predefined spec is still binary so you have to load the plug-in as well but it doesn't use IDs anymore the developer set that makes no sense good but they decided to use file names which is a bit better okay I guess it's for me I still find it a bit simplistic it's good in what it does yeah it's now you have gooeys you have MIDI nice but you cannot go do very complicated things with it gets into his limitations after you want some spectrum analyzer if you want something more like something that looks very big samples you get into issues eventually when it grows the GUI is using OSC which is nice in a way because your application probably already supports it but also means we have to go through the network so if somehow you have an issue in your network you cannot show the GUI for you your plugins anymore yeah but ok this is for the DSS I the one that were mostly interested in is LV - just the new fancy thing yeah because it's I mean I started with the bad things because I want to get them out of the way the idea was to make it extensible and to reuse whatta forget about the SSI but there were some ideas from RDF that were good with the authors at the time so they decided to keep the ideas from there in the slightly different ways not RDF is turtle so and try to support everything makes it extensible so what happened was that someone decided like in the beginning there was no MIDI support for it so someone decided to make an extension for MIDI and then it was not that great actually so there we came with the events and the events were actually not good either so then we have another one so to make MIDI we got three different ways people now only go for the latest one which is the atom but in the history of lv2 we have three MIDI API s3 States three different ways to save two different ways to save state and great three right now this is still active is to the intern two different ways to handle parameters you have the controls from what but and you have more friendly things things that can change if not we'll try to explain everything too much but there's still two different ways to handle parameters we still use mostly the the old way and supporting all the toolkits inside the actual lv2 specification which I because they is asking why is this part of specification the idea was to make it extensible and everybody started to want to add a little bit of everything and you know it became a little bit messy this is the part that is now we're fighting against it like you think something is good at the beginning you don't know you have to learn and we make a mistake and then you only realize a bit a little bit too late yeah like the supporting all the toolkits seems a good idea at a time because you can reuse your system toolkit you can make things in GT k QT but we got into issues because we cannot mix those things well so now what I hope happens is that this last thing gets duplicated so that developers know don't use this please and the next version of harder actually will not load this kind of you guys anymore yeah we which is a good way to force developers to move happily like guitar riffs developers and golf are already working to not depend on GD k anymore so by the time our door gets version six hopefully you already have the the plugins that caught up a little bit with it but that's the farro the way we have quite good things we have a question if asking how many plugins still use the JDK or QT as well I can tell you there's guitar it's the entire collection golf
in father I r dot lv2 there's new tomater q MIDI ARP the plugins from Roy I am synth yeah it's it is a little bit the list is a bit ones yeah but you may
try to focus on the good stuff now we finally have a proper way to save the ID of the plugin which is the URI which is a global event afire for the plugin and this house actually means that you can move the plugin around in our system or in another computer does not matter where it will load the host knows that this plug-in has a unique identifier but it is something that is actually a big is not a number anymore and it always works that's one of the biggest things about lv2 and you cannot have the same plug-in installed in two different places but lv2 is smart about this that it detects which version of the plugin is newer and it will load the new version so if you upgrade your plugin you don't know where to put it they put it somewhere else the old version just gets ignored which in a way is quite nice as well and you no longer have to load the binary in order to get information about the plug-in which means in no longer crashes your hosts when you load the metadata and for this it's also one of the ugly things about lv2 the way they decided to do the metadata which is in a turtle format for users is not an issue because they usually don't see it but for developers that's usually the big thing that they see and think why did you go with this but after you get used to it then okay it's understandable it with one question hmm if asking what's the issue with a turtle and one thing that is more it seems more made for machines rather than humans to read excuse me yeah the yeah
in saying that the entire purpose of it is like this which is true the thing is that if you want to make a plugin you have to write this file yourself to describe what you have in the plugin and you have to write it by hands so it you have for a long time before we have tools to parse correctly this metadata we have some sometimes plugins that got and typos in your plugin metadata and the entire thing there's not load loading correctly and now we have parsers and the library that loads these files this metadata is a lot more strict so it there's an error it tells you so for now it's better but before it was a bit painful and it was one of the things that pushed on developers away the turtle thing you have to write it manually you don't want to do this usually no one questions if asking what I think would be better its I will come to it in the in the next slide after this one good thing we have is full
portable States is not just files that use save like when you save a session you might have references to files in your file system and then you move computers and those files are no longer there or you moved somewhere else Alvie to specify the way that you link the files trying to make it simpler it makes the files in a way that he links to your current directory to a current project so you can export the projects and your files are going to be there if the boolean does it properly of course and which is quite nice usually with other standards they just for portability sake they end up saving the entire file inside the the chunk of the of the save of the plugin so if you load the 100 megabytes pack of sample files you save your project is now 100 megabyte big in sum for some plugins because of this with lv2 we don't need this specification covers taste like this we have a proper embed UI which is not the case of the SSI because the UI is going over the network is an external one now you can probably show it on the host and do whatever you want with it you have time synchronization which there is also one VST for example but not on lot span the SSI there's a lot of many other things we can do as well with lv 2 but I have to get the next one a future for lv 2 lv 3 no I will not count on it because then we have yet another format it's probably not a good idea to do it but some ideas have been spoken about regarding out with 2 developers which is to remove the old stuff like we learn the lessons we should probably not keep all stuff just for complete compatibility sake or something like figure out a way to remove the old stuff and instead of using turtle maybe start using Jason it's but json-ld which is not exactly the same as Jason but it if you read it he's still more it looks more comprehensible than turtle files at least in my perspective and it's asking why not use XML I mean if I was going to use XML I'll probably use turtle instead but yeah lv2 has a lot of package because of bad decisions but even with this I still believe it's the is the best format out of all of them and well it's better to keep one
there's also Jack as a standalone which is kind of like a plugin for Matt he can do audio and MIDI I mean we have the previous presentation showing that you can have audio and then interconnect things so you can imagine every single box in there as a plugin kinda there's transport synchronization between them and now recently we got metadata in jak 2 which means each client and each port can have metadata any kind of metadata inside itself so you can define usually what we have now is icons port ordering some custom names if you want for example in other languages as well and you can define a URL if you want to get more information like documentation things like this so in a way because of metadata can be extensible you just have to define what these properties are what should you you use I really think is healthy too but really what use whatever works for you because that's the point but please don't make another format because I I think we really have enough just a second conclusions and vs2 vested to VST was first lv2 well and a rough start but it's getting there and we're in the good state now I believe VST 2 is very ugly and hacky in a way that there's a bunch of hacks everywhere to make the old stuff work it does work mostly but if I mean if you're a developer I have to handle VST fine until you try to support multiple hosts or multiple plugins many like very frustrating VST - is completely different from VST three that I mean it's something to keep in mind Stern Steinberg can be nasty yes I mean you're not allowed to make VST two plugins anymore unless you sign the agreement before the end of this month but even with open source projects we have the case of a few because we use the reverse-engineered VST file which has the same name for compatibility reasons with the official SDK this open source projects got the mc8 by Steinberg and they the thing we did for now was just to rename the file so it doesn't match and hope I don't know it we hope these the reverse engineering was made in a clearer way this person I mean that's how it works it should not conflict it's open in API but we have to its we have always to be a little bit on watch so maybe just don't care about VST and go for a little lv2 copying lots per was a little bit of a mistake we still have to handle for now and we'll keep the old stuff because for compatibility reasons we don't want to break the old plugin so they already exist but we have we know what exactly what we need to do to make it better just lack of manpower and it's also a thankless job because no matter what you do you're not going to please everyone and if you do one thing that is not going to work well for an excellent application they're going to be mad at you because you just now you give the developers a bunch of work that they didn't need just because you think it's better so eventually everybody hates the guy behind lv2 so I I feel a little bit a little bit for David but we all like you David so it's you're doing a good job keep it up and that's it thank you [Applause]
all right if you still have any questions please let me know yes yes I have a question from from Robin yeah from IOC what's bad decisions can you ask what better decisions Phillip alluded to yeah I mean this is technical things so I didn't want to mention too much but for example the connect port even they would agree a little bit on this that was a bad decision to use because every time you want to run the plug in sometimes you have to connect ports because the buffers have changed and instead you could just in the run function passes threat and this tract contains the the audio buffers which Rob you'll already have an example header file this could be done with using the morph extension so the audio buffer can already contain some other things at the same time by morphing into other thing and if the first member of the struct is a audio buffer you can we can have backwards compatibility with the old plugins although this completely technically something better to discuss some other time but there's one of the examples there's more but I always guess with you I have a question do you think that this whole VST two VSD free the buckle is gonna maybe drive some users from the commercial real towards open standards like lv2 I believe so some already did to be honest because then the only problem is that developers are used twelve it's the VST and having even if not incomplete is that in a bit I'd leave the commentation there is some documentation and they have a bunch of examples because the spec is old there's a bunch of stuff to look at and they count well v2 and they have to learn turtle they have to a bunch of things which were in completely different ways and they also give it sometimes or just sometimes decide to make their own formats because they didn't like every two but it does help a little bit the only thing is that lv2 is not so big on Windows and Mac so we have to take in consideration if they do start playing around with lv2 they don't have a lot of plugins I mean it's just the circular dependency thing there's not all of the plugins and then there's not a lot of applications that support these plugins it needs to start somewhere is not easy but if the same for a VST 3 so luckily for now if not big on Linux we'll see how it goes Thanks this is more of a user question for someone who just uses plugins supposing you're processing power is somewhat limited but you still want to use the plugins that you're used to are there any hands-on ways that you can increase your you know CPU capability without the Machine exploding when you've got too many plugins working at the same time as a programmer do you know of any tweaks that you could do I mean if your local question I know is a bit generic as well but yeah the trick is always to optimize in this case yeah trick not trick because you might spend just a few months to optimize something that takes one millisecond even less that's how it works like if you have a the easy path you make a plug-in then you if you want to optimize the work to loads and work as much as fast as possible that's one of the hardest things to do because you can optimize so much that you didn't even notice that half these things also broke at the same time it's I mean it's tricky usually you wind up just writing assembly in this case not in a higher level but running the actual thing that the binary being system is going to do per plugin I don't know if that's a good enough I'll work with it right so no more questions then thank you very much [Applause]
[Applause]
Feedback