 Welcome. Welcome to this presentation, which is part of FOSTA 2021. My name is Cornelius Schumacher, and I would like to tell you the story of the KDE Free Qt Foundation. This is a pretty unique construction, which is in the KDE and Qt community, which is meant to provide a means beyond the licenses to protect the freedom of the underlying software, which is used by the KDE community and the Qt community. So this presentation will show you where this was coming from, how it works and also what lessons we learned there, how you could apply that maybe to other situations. Let's get started with a few words about myself. I am a KDE contributor since 1999. I got into this project because a co-worker of mine, he was following the relevant news groups, he was following what was happening around Linux and other free software projects, and he was interested in this desktop thing. And there was a mailing list where these questions were discussed, and he pointed me to this new project, KDE. So it took me a bit, but I had a look, found it interesting, found it technically interesting, technically challenging. So I started to write my first patch, and yeah, that's where it started. I'm still there. I started with contributing quite a bit of code, writing all kind of applications. I maintained Korganizer, and it was my first thing into this enterprise where I maintained this application. And from then I did more development, I also got into the governance part. In 2003, I joined the KDE Freq Foundation as a representative of KDE for two years, and later I also was elected into the board of KDE EV. That's the foundation behind the KDE project. We'll talk about this in this presentation a bit later. And I was their board member for nine years, and a couple of years of that I also was the president. My job during all that time was somewhere in the Linux industry. So today my current job is open source steward at DB sister. That's the IT daughter of Deutsche Bahn, the German railway company. And my job there is to help teams to contribute to open source software, and especially also to use open source software. To understand the story, and we have to start at the beginning, 1996. This was the year when, yeah, Windows PCs were quite common. They had 95% of the PC market. Lots of people were using their subcomputers. The Windows on Intel processors. The current version of Microsoft Windows was Windows 95 back then. Windows RT and T also was around. We also had Unix workstations and Unix systems, quite a bunch of them, a number of Unix, different Unix systems, different Unix vendors. And they had something there, which was called the common desktop environment. This was a shared project between different vendors to create the user interface for Unix workstations. It worked. It was heavy. It was a pretty enterprising project. Yeah, people on Unix workstation used it. Some of them might even have liked it. At that time also Linux continued successful development. The kernel version 2.0 was released. Also the Linux distributions. They gained traction. Slackware already was around for quite some time. Debian, Ratat and Zuzo joined that crew. And they distributed a lot of free software along with the Linux kernel to their users. And one thing which is important to note there is that during this time and through this way of Linux distributions, a lot of end users got in contact with free software based on running on the Linux kernel, but of course expanding in many more projects and full solutions, a lot of that. And the user interface for which you typically had on these Linux distributions was FVWM. And this looked like this. So this is a window manager providing the different user interface elements, providing windows, providing panels, menus, all these things. Lots of fancy things like ice watching at the mouse pointer. Not a very uniform experience. Not very easy to configure, easy to use. So not something you would give to end users or where end users would be really happy with. And this is where Matthias Etrich started. He was a German computer science student back at that time. He was known for Linux, user interface for Latich. He developed and he wanted to solve this problem of user interface for end users. So he started with a call which was the birth of the KDE project, a Usenet post on October 14th in 1996. And he said, OK, I want to write a user interface for end users, which is supposed to run on Linux and other Unix-like systems. And I need programmers for that. So he asked for 20 to 30 people to come together to start this project, which actually came together to join him in this endeavor. And in his original call, in his original announcement, he had already two firm decisions. The first of them was that the desktop, the project to be developed should be distributed under the terms of the GPL. So it was supposed to be free software, available to the community, to the users under free software conditions, so that it would be free and available to everybody. The other decision he took was a technical one. And that was to use the Qt library as a base. Qt was a very new product back then. And Qt really liked this library because it was technically a very elegant way to solve this problem of creating user interfaces. He believed in the quality and the future of this library. So this was a strong decision where he said, OK, this is the way to go. This is the only technical way we can actually develop fast enough and create quality software which serves this purpose. So we have to use that. That's the best base. And this was made possible by something he also mentioned in the original agreement that TrelTech, the company behind Qt, provided what he said free source code for free software. So they had a special addition, which would be available for development of free software. To understand that, we have to go back another five years to the year 1991. This is the year where Linux was created, where the GPLv2 was released. Open source didn't exist as a term yet. And during this year, two Norwegian programmers, Howard Knott and Eric Chompang, they sat on a park bench in Trondheim in Norway and discussed their job and what they were doing there. They had to deal with databases and user interfaces, and they saw a gap. They saw a niche to fill. And that was a usable GUI toolkit for cross-platform user interface development in C++. That was their choice for the foundation of this library, this toolkit. And they started to develop that. A couple of years later, they had their first public release. That was Qt 0.9. And you see a screenshot here on the right, some of the widgets in the example, which came with the documentation and the library. So the widgets, which could be used to build a desktop or to build other graphical user interface applications in a quite convenient way. So they had a really nice API. They had the power of C++. A lot of people believed in to be the right choice for this, to do this in an object-oriented way. They solved a lot of problems with that. And this release then was the start of the development of the story of Qt, which became the base of KDE as well. Resets of the technical qualities, one thing we have to look at is the model under which Qt was released. They decided on a dual licensing business model. That was innovative at that time. They were one of the first projects to do that, to release their library, only under a traditional proprietary license to which they sold commercially to their customers with support and availability for all the platforms they supported and everything. That's a classic thing to earn money to fund the development of their company. And in addition to that, and that was the new thing, they also provided a free edition, what they called the Qt free edition, available for free software development on X11. So that was the platform then later KDE chose to use. And they created a license for that, the Qt free edition license, which had the conditions which would allow to use the Qt free edition for development of free software and only for development of free software. So if you would do proprietary software, then you would have to buy the commercial license, the Qt professional edition under the proprietary license and you would get the right to develop your proprietary software. But for free edition, Qt was available and that's why Matthias took it and why it worked as a base for KDE. But it didn't come without complications because the Qt free edition license created quite some controversy because today you would look at the open source definition, you would compare the license with that, the open source definition didn't exist back at that time. So you couldn't certify it as an open source license or something like that. Today, if you would apply the criteria of that to this old license, it wouldn't qualify as open source because it had some restrictions which are necessary if you want to really treat that as free software. So Qt itself wasn't completely free. It had some clauses like, you couldn't do changes to Qt and distribute the changes and you had to notify TrialTek if you made commercial use of the free edition. So this is something where there were some restrictions. It didn't restrict the development of KDE as a free software project, but Qt itself wasn't free. And there was quite some debate about that and quite some pressure on KDE as well because of this decision from a technical point of view. It made a lot of sense from a licensing point of view. There were open questions. The other question was that what happens if TrialTek stops making Qt available for free software development? So if they cancel the license, if they go proprietary only or if the company goes out of business, there was a reliance on this company and especially as Qt itself was not free in the sense of free software. There was a problem that you couldn't just take it and develop it on your own. You would have to rely on the company to provide it. So this was a dependency which also was critically seen by a number of people. And the third concern there, and that was also a concern of the time, Kader Dahlheimer, one of the early developers of KDE, he points this out. He said, yeah, you have to understand that at that time people were afraid of companies buying other companies to shut down their products. And with Qt, there was a concern that Microsoft would buy it and shut it down because obviously there was some competition. Microsoft's software was also providing user interfaces, libraries for that. So there was competition and people were afraid that maybe because you had this dependency on this one company that this could be used to shut the project down. And this fear wasn't completely unfounded. This is one advertisement Microsoft put in German computer magazines roughly at that time, where they instilled this fear of Linux not being a reliable operating system. So when they say, okay, if you use this free stuff, you might get mutations. And this of course was a fear which they instilled to undermine this model. So there were concerns about how Microsoft acted at that time, which were not completely out of the sky. In 1997, there was a pivotal moment in KDE's history. This was the first developer meeting in Ansberg, a small town in Southern Germany. And this was at that time, a lot of people were Linux enthusiasts and they put Linux into their internal IT infrastructure. And there was a company, a manufacturer of wafer makers actually, which is still around today. They had Linux enthusiasts who was maintaining systems there and they invited the KDE developers to come together here. The KDE developers needed a place and they provided them with X-terminals and network infrastructure so they could work on KDE. And this was the place where the developers came together to polish KDE, to develop KDE, to write software there to make it ready for the first stable release. But it also was the place where they were able to really discuss these questions about the licensing and about the threat which was there from the different directions and come to plan how to deal with that. And it happened actually at a pretty delicate moment because two weeks before the meeting, Gnome was founded. Gnome as the competitor to KDE as a free software desktop. It was founded partly because of this license controversy. So there was pressure there and there was a need to really decide something. And to this meeting, Eric, one of the founders and Art, one of the first developers at Trautek, they joined the KDE people at Anspec at the meeting. They traveled to Germany and joined the group to discuss these questions. And one thing you have to notice that at that time Trautek was six employees. So not a huge number, but six full-time people working on this toolkit, so providing a base. And KDE already was 200 developers. So the call for developers was quite successful. There was momentum. A lot of people rushed into this as developers to help developing the desktop, developing applications. So in some way, this strategy worked for Trautek. It worked because there were developers, free software developers using their library. And for KDE, it also worked because there were people and there was a model to actually fund this full-time development of the underlying toolkit. So there, they had the discussions about this debate, what to do about it, how to enter the debate about the freedom of Q because the intention was to make it available for free software. And Trautek came with a surprising offer. They offered to create a legally binding agreement between the community and the company, which would guarantee that Q stays free forever. And this was something which came as a surprise. KDE didn't expect that. That's not what companies typically would do, give things away just for free. So there was a debate about that. And in the end, they decided, and they came to a conclusion and agreement and said, okay, let's do this. Let's create this agreement to add an additional guarantee for freedom, which is not covered by the license. And a statement of intent was signed. That's a short statement. You see the signatures of the two sides there, the Qt people and the KDE people. And this lies out the fundament of the KDE Free Qt Foundation, what it is and how it works. So the first thing is that the purpose of the foundation was defined to be, to keep the Qt free addition available for free software development. So the X window system, so the system KDE relied on at that time. And the way how this was supposed to work was that in case that the Qt free addition would be stopped, would be discontinued, not developed any further, then the foundation shall have the right to release the Qt free addition under the BSD license. And with that, they would actually with the BSD license, it would open it up to all software development, free or proprietary. And it would also allow to create another company with the same business model or something. So with the BSD license, there would be all freedom. You would need to, in the future also on one hand keep Qt free, but also to develop it further and maintain and maybe create a new ecosystem around that. So this was the basic idea. And I would try to explain that to the lawyers when they were formulating the agreement and the community contract they wanted to create here. So they hired a prestigious lawyer and tried to explain them how this was supposed to work. And the lawyer had some trouble there, but finally he was saying, so you are saying that you want to pay me to create a bulletproof setup so that you can never stop giving something away for free. And that's where Eric said, yes, that's what we want. How does that work? So if we look at the construction in detail, we see the KDE Free Qt Foundation. That's the organization which was created for this purpose and only for this purpose. So very clear scope. And from the two parties, the Treutech on one hand, the company owning Qt and KDEV representing the KDE community, they were sending representatives to this foundation. KDEV didn't exist when the community started to talk about the community contract. So this was one thing which happened back then that the EV was founded. EV is the German abbreviation for registered association. That's a typical nonprofit organization in Germany which is used by hundreds of thousands of associations. It's a typical legal nonprofit form. And this is KDE created that for the KDE Free Qt Foundation, but also of course to have an organization to back the community in terms of financial representation, legal representation and giving support. That's what foundations typically do. I mean nowadays we are very familiar with the concept and at that time it was something newer so it also took some while to get it right and create the bylaws in the right way and so on. But it was put in place in time to sustain the KDE Free Qt Foundation here. And the way how the foundation, the governance in the foundation works is that you have two representatives from each side, two from KDE, two from Atrotek and they form the board of the foundation and that's the only people who are there. They vote about things, they discuss things and there's one special twist here. When votes are done about the agreement then in case of a tie the KDE side decides. So the KDE in effect has the majority in this foundation. So that means this agreement to protect Qt and to make it free is something the KDE under the conditions which are put out in the contract can trigger even against the will of the company owning Qt. And that's the specific leverage which was put into this foundation to make this guarantee effective. And the details of this mechanism are then in this agreement, the license agreement between Trotek and the KDE Free Qt Foundation where all the details are formulated how Trotek gives the license, the conditions when the license can be exercised to release it under the BST license. What has to be taken into account there what is the process there and so on. So the license agreement is then what actually has the details about this community contract when it triggers and what it covers. So these three elements are what is there which is the fundamental construction and setup of the foundation. And there are of course quite some details there. This is just to write it down what I explained in the diagram. There are a few twists here for example the definition of what it means to discontinue Qt is defined in a way that if no major update of the Qt Free Edition is released for 12 months then the foundation can trigger the agreement and can use it. So there are more of that we will talk a little bit more about that a little bit later. So what are the consequences of the setup? This protects Qt, the library, the toolkit which can be realized on for free software development against things which could happen to the owner of Qt. So Bankruptcy is one case the company goes out of business or takeover and the company acquires them and maybe does things in a different way What is the change of plans? Maybe the company would at some point decide to take the library proprietary or to not develop it any further. So for these cases the agreement provides this protection with the BSD license or this option to release as the BSD license and this would have these two effects on one hand that Qt could be used for any project for software as well as proprietary. A very liberal, permissive free version then which obviously is not compatible with the business model of TrialTec at that time or in general this proprietary copy left business model so this is really a protection against anything which could happen to the freedom of the project there the availability of the project for free software development. And the other nice effect of that which is also I think an important element is that this releasing the project under the BSD license also allows to build up a new company with a similar business model so somebody else could continue in case the original owner is not able or not willing to continue that anymore so you could build up a similar model so you have some more stability guarantees to create a stable environment there which also would provide at least the opportunity to fund development in a way which is necessary to put in the effort which is required. So after some months of discussion and formulation and negotiation they finally signed the agreement KDE and TrialTec. They also wrote a press release where they announced the agreement and this contains a nice sentence which I think captures the vision of the agreement quite well so it ends with we do this to prosper in a mutually supportive fashion so what they realize there is that preserving the freedom of the library there and the availability for free software development that this is good for both sides so to put this into a good direction underlying cause of the agreement and the ambition of the agreement to make this successful for the free software community but also to the company which is working in this ecosystem. The agreement itself are only three pages that's quite short that's the first version there also is the chart of the foundation which governs this construction about the membership and the voting and the majority and so on so there's some additional text but the actual contract about when the conditions are triggered and what happens then this is in this agreement basically just one page of legal text and it was just signed in time for KDE 1.0 KDE 1.0 was released July 1998 first version based on Qt 1.2 so very early some of the people who are around for a longer time I'd remember these versions some nostalgic thoughts this was the first stable release and it looked like this still not the most beautiful and most advanced desktop but quite a step forward so very consistent already and it had a lot of momentum lots of people were jumping on this using it developing with it and this was the beginning of a series of quite successful releases if we look at that at the evolution KDE 2.0 was released in 2000 two years later version 3.0 of course there were more versions of KDE over time so this was the continuing development also Qt developed and Qt did some license changes in 1999 with Qt 2.0 Tritec decided to go away from the Qt 3.0 edition license and use a new license they also wrote that themselves the QPL and this license actually was an open source license so at that time the OSI was just founded there was the open source definition and the QPL was accepted as an open source license so a lot of these debate about the freedom of Qt itself went away at that point and finally they decided to do another step and to retire the QPL and move on to the GPL and that of course was the time when we had the standard license lots of other people were also using so this provided the point where Qt would consider to be free by all the people around yeah in 2005 Tritec did another step because we have talked about the platforms and the X-Windows system X11 so Qt had this model where the Windows platform was only for commercial customers under the proprietary license with Qt 4.0 they decided to put the GPL also on the Windows version for Qt this allowed also for KDE to finally port applications to Windows make their free software available on this platform as well so this was a step which extended the scope of the license at this point one thing which also happened there is that the agreement itself the KDE free Qt foundation agreement was involved there was a second version of the agreement to adapt to these license changes to also adapt to this technology evolution advancement so there was another draft of the agreement discussed and negotiated to adapt to that and one of the central questions of all these adaptions of the agreement was at that time and still is what actually is the Qt 3 edition so what is a legally complete and binding version of what does it mean to be in the Qt 3 edition what is contained there also what does it mean to release a major update what does it mean to discontinue that would it be possible to move parts of Qt into another product call it differently and then release it under a different license so how do you protect against that how do you cover the different platforms which are covered by the agreement so what about Windows maybe future platforms what is about when the technology changes and then of course also what licenses are acceptable so not only in the not only the license of Qt itself evolved but also the GPL for example evolved there was version 3 and so how is this reflected that's all these questions where then you had the KDE3 Qt foundation had to put in the work to find answers to them and formulate that in the agreement in a way which was balanced and still binding and serving its purpose in 2008 KDEV got an email and this email came from the Trolltech founders and they said we sold Trolltech to Nokia so this was the point in time when the agreement got tested so that's what it was designed for so in case of an acquisition you have a new situation a new owner what happens with that will the new owner keep up the freedom which is there will keep up the support for the free software community and how does the agreement hold there is it actually strong enough to survive such an acquisition and we cannot say it was strong enough but KDEV was at the table from the beginning there were negotiations between KDEV and Nokia so one of the first meetings that was an interesting meeting because Nokia managers came to Frankfurt in Germany where KDEV had its first office we shared this with the Wikimedia EV in Germany there with one shared employee so at the very beginning small office the Nokia managers coming there I think it was the day when they published quarterly earnings numbers and they were proud of how successful the company were of course on a big big scale at that time KDEV of course was much smaller in terms of organization but we had the strong community and I think that was the reason also why this was interesting because Nokia needed the KDEV community and the Qt community and the wider community as leverage that was one of the values they saw in Qt and the agreement actually enforced that and made it really necessary to have these conversations with Qt 4.5 the LGPL was added this increased the licensing options there made it available for use cases but before there was a third agreement reflecting these changes with licensing but also with the new owner so this again took a round of negotiations and also a process was started to put Qt under open governance up to this point in time Qt was open source, was free software so you could use it, you could change it but there was no structured way to contribute to the upstream version so this changed with the introduction of open governance, so a system was put in place where people could contribute, could also become maintainers of part of Qt who were not working for TrollTec or Nokia then and this also caused an inflow of software from the KDE community where people contributed their changes they had put on top of Qt in a layer in KDE back into the upstream version to have a more and better maintained system yeah, over the next years or the next decade almost there was more evolution more development, Nokia decided to sell Qt again, they put it into steps into the Finnish company Digia so they acquired the Qt business and the writes on Qt Qt 5.0 was released now under the open governance model Digia also then formed a separate subcompany, the Qt company that's the owner of Qt today to bundle the Qt business in one company and this company then in 2016 when public this is where we are today Qt 6.0 is the current version released in December and during these changes again new owners different legal situation, the agreement also was adapted and was evolved, the fourth agreement the fifth agreement, continuous evolution there and we talk about that in a second there is an interesting plot twist in 2013 Microsoft actually bought Nokia so at that time Qt already wasn't the hands of Digia but the fear from the 90s that Microsoft might acquire Qt to do whatever evil things they meant to do to that this fear almost become reality here but Qt already was not part of Nokia anymore at that time so nothing happened in this area where are we today, what are the lessons we learned first of all we can say the community contract worked, the mission was accomplished if we look at the KDE Free Qt Foundation it's around for more than 20 years it's alive, there are people there working on it, it's not a huge amount of work, it's not a constant activity but it's something which always is when changes occur then these get addressed and the purpose has been accomplished Qt stayed free through also sometimes turbulent times so the different acquisitions there was a lot of also politics and a lot of dynamics there which might have caused trouble but the goal of the foundation to keep Qt free that actually worked and both KDE and Qt had a lot of success as projects and also impact so we can say that the original goal was accomplished and if we look at that how that worked I think it's kind of key here to look at the two sides of licenses and this community contract so if we look at the license that's what guarantees us the present freedom so if I have the code under the free software license I can use it I can develop it, I have the freedoms which are guaranteed by the license but this only is valid for the code I already have for the future of course I can develop it myself but I have to trust or rely on the people owning the full rights on the code to do what they promise to do and the community contract adds this additional layer of protecting the future freedom as well so this is this forward looking thing where you say okay in the future you stop releasing it then something happens which makes it free so I have this guarantee for the future and this is I think a good combination because in addition to that it also adds this need for continuous conversation so the community has to be in contact with the company and this balancing out of interest that happens on an ongoing base and for this the community contract provides leverage which otherwise just with the license wouldn't be there there are a few questions which sometimes asked in the context of the KD3Qt foundation and one of these is what about a fork so it's Qt as GPL so we could just fork it right and that's true the GPL allows forking obviously you can develop a new Qt version under the GPL and to your own fork the company or anybody else working on it of course there are some drawbacks the first is obviously it would split the community so if you create a fork then you have in total less people working on each version so this might be a problem in addition to that also forking wouldn't allow this model of proprietary dual licensing business model to work with a fork you can do the GPL version I mean you can sell products based on top of that but you can't do this proprietary dual licensing thing which if this is the way how the development is funded might be a problem if that's not possible anymore there might not be a sustainable way to fund the fork and the third thing is that this is a clause which was added in 2004 and can be terminated if KDE stops using Qt so this is part of the ongoing balancing between the interests of the community and the company that it was added there to make sure okay if the KDE community stops using Qt then actually there's no reason anymore there to provide this community contract the original reason is gone so in this case Traltech or the owner Nukia, Digia, the owner of Qt they're going to terminate the agreement and say you're not using it anymore so you're not bound to these conditions anymore we go in different directions in this way also KDE becomes kind of the steward of this part of the freedom of Qt for the rest of the free software community so that's something which I think is important and the people in there are aware of to use that in a responsible way the other question I often ask this is the KDE Free Qt foundation a good model for other projects this dual licensing situation with the proprietary license and free software license or specifically a copy left license is used by other projects or could they also add this additional layer of freedom by adding such a community contract and I think you have to look at this situation here I think there are situations where this actually could be an exemplary setup so if you look at these single vendor projects where vendor holds all the rights to be able to do this model of proprietary license and a copy left license this requires a CLA from contributors so that the vendor has the rights to do this dual licensing and this adds some asymmetry because in this setup the contributors which are contributing to the project they and the community in general they have less rights than the company because they have the rights under the open source license and the free software license that's what all of them have but the company in addition has this additional right to use the proprietary license to fund their business and this is an asymmetry which can be demotivating or the reason to maybe distrust the company or you have to trust it you have no further leverage and there an agreement a community contract in the style of the KDE FreeQ Foundation can add some balance there so you put on the other side the agreement which gives the community additional rights that's this majority situation in the KDE FreeQ Foundation where the agreement can be triggered against the will of the company the conditions are met and there you have this shared pledge for the future that freedom is there which also gives people more guarantees for contributors more safety that they can actually be sure that the software is available under the conditions they are trusting in and you have this legal box to balance out the imbalance of the CLA so that's where something like that could work one thing you have to be aware of is that this requires some maintenance this is the contract how it looks today the latest version of the agreement the license agreement it's not three pages anymore it's some more pages and the questions we discussed before about what is in queue what licenses are covered what platforms are covered and so on so this was formulated in more detail and fleshed out and adapted to the current situation and more components came into that so obviously with the development over many years many factors changed and some of these have to be reflected in the agreement that's what happened there on the other hand you also have to look at that that's more than 20 years of development adding 10 pages to a contract in 20 years is something which actually can be a reasonable effort and to just visualize the development a little bit better here so this is the scope of the licenses and the agreement over time over the 25 years of history here license-wise we went from the Q3 edition over the QPL and the GPL then now to the combination of GPL and LGPL the community contract at the beginning only covered X11 windows was also around but not covered by the agreement so the KDE ports to windows at the point where Qt was available under the GPL where possible but this additional safety that the Windows version would still be there for the time being and for the future there was no additional guarantee there so this was only added quite a bit later where the community contract was expanded to also cover the Qt version on the Windows platform there are two more things I would like to mention in this diagram so one is Wayland this is in this dotted lines box here because it's kind of covered by the agreement the agreement says and that also was something which was added later over time that not only X11 is covered by also any successor of the system what a successor is something which is determined by the board of the KDE free Qt foundation in this case actually the simple majority where KDE decides it's not sufficient so this is not completely cleared yet if Wayland covers false under this condition or not so this is something where eventually maybe another change in the agreement is necessary and the other thing is Android Android actually the support for Android so the mobile platforms the desktop platforms were covered from the beginning also macOS which then always was under the community contract the mobile platforms were only added later Android actually was there from the beginning because this emerged from the KDE community so the KDE community developed the support for Android and then later contributed it to the Qt project and this happened under the condition that the community contract would be extended to also cover Android so that shows again this example where the ongoing conversation there helped to shape the conditions in a way in a balanced way in this case good for the community but also of course good for the company because Android was added later this also was extended to iOS that's where we are today there are a few other platforms which are there but these are the most relevant from the KDE and free software point of view the last thing which I think you have to consider if you are looking at this kind of community contract this kind of agreement is that it takes courage to do that because it has this future perspective where you are the thing Eric had trouble explaining to his lawyer that he wants to make sure that he can't stop giving something away for free that's of course a bet in the future a bet on the power of the free software community and the power of the model also on the quality of the product and the development and the people around that so it takes courage it was a bold move but it did work because people put in the effort to make it work yeah so the KDE freecute foundation we talked a lot about legal rights about licenses about contracts about community about the details of how this developed and how this works and what are the pitfalls there what are the advantages but I think the fundamental thing here to look at is actually freedom this is the core of the KDE freecute foundation because freedom is good for business and it's good for the community and in general it's good for the world and the statement from the original announcement of the KDE freecute foundation I think this captures it beautifully because it says we want to prosper in a mutually supportive fashion and that's what is enabled by going away which is based on freedom so thank you for watching this presentation we are at the end of the story I'm happy to talk more about that so if you want to discuss it please feel free to reach out to me and I wish you have fun with more presentation of hostem 2021 and stay safe