Powered by Indico
v3.2.7
Akademy 2023 will be a hybrid event, combining on-site and remote sessions, and will include talks, workshops, Birds of a Feather (BoF) meetups, training and coding sessions. The conference is expected to draw hundreds of attendees from the global KDE community to discuss and plan the future of the community and its technologies. Many participants from the broad Free and Open Source software community, local organizations and software companies will also attend.
The space industry is evolving rapidly, with open-source solutions playing an increasingly vital role. The Libre Space Foundation (LSF) champions this movement by developing open-source space technologies that make space exploration more accessible for everyone. In this talk, we'll introduce the Libre Space Foundation and discuss the relevance of free software in the space sector.
Key points to be covered:
As per tradition, each Akademy has a time slot for our Goal Champions to present what's been going on with the Goals, and plans for the coming months.
In the beginning of 2022 an assessment of the accessiblity of Kleopatra was performed. Unsurprisingly, Kleopatra didn't score too well. In fact, the accessiblity for blind persons and for motor impaired persons was rated insufficient. Over the course of last year, I have fixed or at least improved many of the findings mentioned in the report. In the follow-up test, that was performed in the beginning of 2023, Kleopatra was rated accessible with minor limitations for visual impaired persons and motor impaired persons.
In this talk I will give a short overview over the problems and how I addressed them with the help of Qt or despite of Qt.
Software has a big impact on how much energy a device uses, and there are many reasons to minimize that, from battery life to climate change. But how can we optimize this, and how do we ensure changes we make are actually improvements?
KDE e.V. has done a lot of work to support the KDE Community over the last year. In this session the board reports on the work of the organization and future plans.
I will start out with the fact that snaps have had over a million downloads and with those kind of numbers, they cannot be ignored. I will continue on to describe here my journey in creating a vast amount of snaps, the automation of said snap building using invent.kde.org and Ubuntu lanuchpad builders. I will explain the hurdles I have overcome and what needs to be done to keep the snaps updated and how developers can help ensure the users are getting updates in a timely manner. The hard part is done, I have made it easy, just a few more minutes of your time at release.
In this session we will explain what Flatpak is, why it's interesting to KDE and talk about the various endeavors where KDE interacts with Flatpak, flathub, CI, binary factory, etc.
The Working Groups of KDE e.V. support the organisation and larger KDE Community in various matters. Here they report on their work of the past year as well as upcoming plans.
Many resources exist detailing the ins and outs of technical documentation, yet most are concerned with practices done in enterprise environments, leaving open source—and its anarchic/do-ocratic collaboration style—in the background.
This talk explains the different ways in which KDE handles documentation and summarizes the relevant content found in multiple technical documentation books to serve as a general metrics for what KDE should be striving for in its documentation.
Spoiler: No.
But how far are we on our way to full KF6 glory? And what challenges lay ahead? In this talk we are going to look at the current state of Qt6/KF6 porting in KDE. Application developers will learn how porting works in practice, how to approach it and what to look out for. We are also going to look at the remaining challenges for developing and releasing KF6 and a tentative release plan.
This is going to be the last KF6 talk, I promise!
Plasma is being porting as well to Qt6 and KF6. Some things will change, some things will stay more "stable". This talk will go over what this will mean for the end user, but also what it will mean for the developer.
It will be presented the VDG vision for the user experience, the current state of affairs and what will change for the plasmoid author, what api is different and why
Slint is a UI framework written in Rust with hand-crafted bindings to Rust, C++ and Javascript. Slint scales from microcontrollers with no OS and just a few KiB of RAM all the way up to desktop UIs backed by graphics accelerators.
This presentation shows what slint is and how to build a small UI with it.
Do you know this nervous feeling when powering on an embedded device for the first time? Not sure whether you will see smoke, an awesome Plasma desktop, or just a blinking bar on a serial shell followed by nothing? -- Embedded devices are fascinating! And in this talk I want to show what we have in the KDE community to get you favorite KDE software on them.
In this talk I want to cover:
- the tooling we have in KDE (our Yocto layers) to easily create embedded devices and how that works
- which devices are most interesting at the moment, in my very subjective view, and which we use for our KDE demos (yeah, say "RISC-V"!)
- the concept of an immutable image, which is created by a build system (like Yocto), put onto a device and updated by fail-safe steps, but also the topic of containerized apps and why we need to look into them for embedded devices
- my ideas about next topics and directions that we should pursue in our embedded area and how easy it is to join this quest :)
KRunner is an essential part of Plasma, providing a fast way to access applications, files, and utilities on both desktop and mobile. In this talk, we will explore the evolution of KRunner and focus on the present state as well as future plans.
Three years ago, an Akademy BOF was held to discuss KRunner and specifically DBus runners. Since then, KF6 refactorings and cleanups have significantly affected the API, resulting in important changes and new features. In this talk, we will summarize these changes and explore how to port and improve existing runners.
Last year marked the 20th anniversary of the Kdenlive video editor, and the start of a shift in our development. Discover the team behind this very popular project, and what we learned during these years - what are our strengths, how we are organizing our roadmap and what we are planning to avoid past mistakes and keep growing.
We will also talk about the future of the project and the exciting things to come!
Games and Applications provide a few different methods of feedback to
users. Flashy graphics and sounds are primary, but there's another
method that can be added quickly and easily. Speech can add another
layer of feedback to your users. In simple cases, a i18n("Well done!")
spoken on speakers can be magical depending on your target audience.
QtSpeech makes this easy but is also flexible enough to let users customize
voice settings if you expose those to them.
Maintaining large C++ codebases with hundreds of developers is a complex problem.
In the KDE community, work is being undertaken to improve documentation, as well as to automate and systematize internal processes such as testing and QA (see current KDE Goals). Our tool, currently under development sponsored by Bloomberg, supports these processes, making it possible for developers to visualize and, therefore, better comprehend existing C++ architectures. This visualization, analysis, and development tool is based on the ideas from John Lakos' book "Large Scale C++ Software Design".
Our presentation has two parts. In the first, we explain how the ideas from John's book are implemented in the tool; in the second, we demonstrate how we've been using the tool to understand KDE projects, improve their code quality, and fix architectural suboptimalities.
As reflected in the 'About' tab in KDE apps, i.e., "a world-wide community of software engineers, artists, writers, translators and creators ...", we are a large and diverse community.
How does such a large and diverse group of people communicate? What infrastructure currently exists to support that communication? And where are there opportunities for improvement?
In this talk I will (attempt to) map out the communication infrastructure at KDE. I will explore various roles (e.g., software engineer, artist, writer, etc.) at various stages (new vs. seasoned contributor) in terms of how a KDE contributor navigates that infrastructure.
The goal of the talk is to spark a discussion about what works and where we can improve when it comes to internal communication -- and, most importantly, how that influences community cohesion.
In this talk, we will explore the Matrix and ActivityPub standards and how they can be used outside of their primary purpose, by powering everything from comment systems to calendar invitations, coordinating itineraries, and synchronizing data.
Historically KDE has not been involved with how our software is deployed. Nevertheless, this model has shown its limits and it's time we make sure we are still ahead of the wave as we are aiming to support different software stores as well as hardware shipping our software.
This presentation will explore how our ecosystem has changed and its implications by taking a look at how linux distributions have evolved and discuss where KDE fits in there, concluding in some ideas on how KDE can adapt its deployment strategy to ensure that it remains relevant and accessible to users.
In the past year we've seen the advance of selenium-based infrastructure to conduct GUI testing of our software. I'll show you how it works and why it's amazing.
While the X11 Display Server had network transparency as a core feature, Wayland compositors are not required to implement things the same way. In fact, the Wayland protocol itself has not been designed as a protocol for network use. Yet remotely controlling a desktop remains an important use case for a number of users.
For KWin, we have been working on several features over the past years that together allow us to implement remote desktop support within KWin Wayland. Together with a new library called KRdp that implements the RDP protocol we now have a solution that allows controlling any KWin Wayland session over a network connection. Moreover, this includes some features we were not able to offer before.
In this talk I will go over some of the history of remote desktop support in KDE. I will also talk about some of the features within KWin that we make use of to get all this working. Finally I will talk about implementing the RDP protocol layer and the other parts needed to get all this together.
This presentation revisits Fedora KDE to discuss one of its major initiatives: removing the dependency on the classical X11 server.
Over the past few years, the Fedora KDE SIG has been working toward eliminating the usage of the X11 server in the default session setup. With Fedora Linux 38, we now rely on Plasma Wayland from login to shutdown! In this talk, we'll discuss how Fedora is preparing to only offer Plasma Wayland as Plasma 6.0 looms over the horizon, and what that means for users and developers.
One way to find bugs is to have users test changes as early as possible after they are commited, or even better, before they are committed, during the merge request process.
With Flatpak builds in Invent GitLab CI and Fedora Kinoite Nightly, we are making that possible respectively for KDE Apps and KDE Plasma.
KDE Apps are now distributed as Flatpaks via Flathub and we are setting up GitLab CI in KDE Invent to build Flatpaks for each merge request. This lets users test fixes for KDE Apps directly by downloading the Flatpak bundle produced as part of the merge request. Feedback on bug fixes can thus happen before the merge request is merged.
Fedora Kinoite is an immutable or image based version of Fedora that is built with rpm-ostree and includes the KDE Plasma desktop and KDE Apps. Kinoite Nightly is a variant of Fedora Kinoite based on the latest stable release of Fedora but includes nightly builds of KDE Plasma packages instead of the stable ones.
With Fedora Kinoite, users can update their system as a whole like an image and rollback any update if they hit a major bug. This capability lets them try out upcoming changes in KDE Plasma without fear of ending up with an unusable system as they can always go back to the previously working version.
With both those changes, we are working on making testing development versions of the KDE Plasma Desktop and the KDE Apps more accessible for non technical users.
Here we don't stand in front of you and talk about amazing things are and how things work. This is the opportunity to ask KDE Wayland developers your burning questions.
It doesn't matter if
this is your chance to do it, anything Wayland related goes!
We're doing more and more things remotely, and will continue doing so.
There are multiple tools, open source and not, doing remote conferencing for people-to-people interactions.
However, there are few tools and libraries to do remote control of machines. And by machines, we speak about normal machines (think TeamViewer or VNC), Virtual Machines (think Citrix or Cloud Desktop), Cloud Gaming, Drones or Robots.
In all those use-cases, we need a high-quality, 0-latency video feed, and bidirectional input forwarding.
This is what we've done with the Kyber project, which provides a cross-platform application and SDK, to control any type of machines, independent of the hardware and the Operating System, using different video codecs tuned for the best latency. In addition to those high-bitrate video feed, we've developed the infrastructure to forward every type of inputs (Keyboard, Mouse, USB, Gamepads...) and virtually replug them on the distant machine.
I plan, during this talk to explain how it works and go into the technical details.
In this talk I am going to show you how over the course of just a few evenings I managed to feed live data from my solar installation into Plasma’s System Monitor.
How cool is that? You can have both CPU load and photovoltaic energy production side-by-side!
It’s a perfect example of how simple it is for a project hosted outside of KDE to make use of their libraries and how versatile and high-quality they are.
While this project is nowhere near a fully integrated Smart Home solution, it’s here to serve as an inspiration for the KDE Community of what lies out there beyond localhost.
qmllint started its life as small command line utility checking whether QML files are syntactically valid. However, it has evolved to to be much more. This talk will tell you about the various checks it can do nowadays, how to integrate into CI pipelines, mention perquisites to make the most out of it and tease its upcoming plugin API – all in 5 minutes! Curious and inspired minds are then invited to join a BoF session about improving qmllint later during Akademy.
For the first time in many years, Plasma once again includes a first-run wizard, called "Welcome Center". In this talk, learn the reasons behind this addition and whether it's part of a secret plan to bring back Kandalf.
Our sponsors will have a few minutes to talk about something they want the KDE Community to know.
The Akademy Awards recognize outstanding contributions around KDE. Last year's winners will this year's winners.
In this training we will get a solid look at the "KDE Stack" and how the different pieces fit together. There will be a strong focus on the KDE Frameworks offerings and also on how Plasma leverages them.
To better understand the context of the KDE technologies, we will also have a biased tour of their history and we will explain some known and lesser known bits in Qt with a different light.
Depending on the explored topics, we will provide either high level diagrams of the interacting pieces or code snippets.
If you are a KDE contributor whose first name is David or you've been contributing deeply to KDE Frameworks and Plasma the past few years, this training is probably not for you.
That said, if you are a KDE contributor, or an aspiring KDE contributor this training is definitely for you. If you're working on a Qt application and wondering what KDE can bring to the table for you, it might be of interest as well.
Prerequisite: some experience with using Qt and C++ to build applications
To take part in this training please join the Big Blue Button room at https://meet.kde.org/b/ken-dmw-ofr.
There are many options to bridge the gap between the C++ core of our applications with QML, whether we use that for UI with QtQuick or for some other reasons such as application scripting.
We will start with fundamentals and work our way through to more advanced APIs and techniques, allowing us to understand how Qt itself provides their QML components and also enabling us to do the same.
Prerequisites:
Working Qt development setup wit Qt 6.5
Basic understanding of Qt and its object model, fundamentals of using
QtQuick for UIs
NOTE: This training is only available for contributors with a KDE developer account. For details about how to join if you have one please see this page on invent. If you don't have a developer account we encourage you to contribute to KDE and then apply for one.
Designs to life.
Bridging the gap between designers and developers is and was the promise of QML.
QtDS, expands on that promise by trying to lower the {code} barrier for Designers.
In this training we will try to cover the basic elements of QtDS, what it is want what it is not.
Table of contents:
Part 1- Intro the the UI
Part 2 - Figma export example // side note# (this is the part that the Qt
company is not yet giving for free but its useful to demonstrate)
Part 3 - UI creation.
Part 4 - Animations / Timeline manipulation
Part 5 - 3D Integration.
Part 6 - QML behind the scenes
Part 7 - Using effects
Part 8 - Using Controls.
Prerequisites: Qt Design Studio would be very useful to have installed
NOTE: This training is only available for contributors with a KDE developer account. For details about how to join if you have one please see this page on invent. If you don't have a developer account we encourage you to contribute to KDE and then apply for one.
This workshop aims to provide attendees with the basics of Hugo and notable functionalities of our hugo-kde theme. In the end the attendees can create/generate a static site using Hugo and hugo-kde.
Prerequisites: HTML basics
To take part in this training please join the Big Blue Button room at https://meet.kde.org/b/ken-dmw-ofr.
Participants in this workshop will learn how to create a multilingual desktop Qt Mancala game application. A computer based opponent will also be introduced to allow practice.
Prerequisites: Attendees will need some knowledge of version control. A local development environment for KDE/Qt applications would be great, but cloud accounts can be provided.
To take part in this training please join the Big Blue Button room at https://meet.kde.org/b/ken-dmw-ofr.