Welcome to a new issue of This Week in Plasma!

This week, Plasma folks shifted to bug-fixing and polishing work for Plasma 6.8. As of the time of writing, there are only four open regression reports for Plasma 6.8, which means either the release is already amazing, or people aren’t testing the beta release enough! You know what you need to do. :)

Also, notice that we have bug fixes going into four concurrent Plasma releases right now. FOUR! That’s a lot of release management, but it seems like the Plasma team is up to the task!

Notable UI improvements

Plasma 6.7.6

System Settings’ Wi-Fi & Networking page now fully fits within the window at its default and minimum size. (Marco Martin, KDE Bugzilla #443553)

Plasma 6.8

On KWin’s Overview effect, highlights for adjacent virtual desktops no longer touch. (Nate Graham, KDE Bugzilla #523656)

Kup’s backup progress notifications now show the elapsed time, and average speed information is now more accurate. (Méven Car, kup MR #62)

Did another few rounds of visual polish on KDE’s desktop portal dialogs to increase their information density and visual consistency. (David Edmundson and Oliver Beard, xdg-desktop-portal-kde MR #628 and xdg-desktop-portal-kde MR #630)

Plasma 6.9

Renaming a file or folder on the desktop now shows all the standard warnings and confirmations when necessary. (Ramil Nurmanov, plasma-desktop MR #3684)

The Weather Report widget now warns you when the weather provider you’ve chosen might report less data than you would expect. (Ismael Asensio, kdeplasma-addons #1127)

In the Clipboard widget, buttons to invoke actions now only appear for entries that have actions associated with them. (Tomáš Hnyk, KDE Bugzilla #440727)

On System Settings’ Wi-Fi & Networking page, the “speed” setting has been renamed to “speed limit” to clarify its purpose. (Fernando Marcelino Muniz, KDE Bugzilla #523099)

Notable bug fixes

PulseAudioQt 1.9.0

Fixed a very odd issue whereby multiple audio devices could end up in a “selected” state, making it unclear which device was actually the default one, and impossible to change it. (Harald Sitter, KDE Bugzilla #500968)

Plasma 6.6.7

Fixed a bug that could make the login screen fail to appear if no screens were present early in the boot process, and connected later. (Oliver Beard, KDE Bugzilla #520720)

Fixed a bug that could occasionally make Plasma crash on login, seemingly randomly. (David Edmundson, plasma-workspace MR #7042)

Fixed an old bug that could make Plasma crash seemingly randomly when something made a System Tray item animate in just the right way at just the right time. (David Edmundson, KDE Bugzilla #487699)

Fixed a recent regression that de-synchronized the brightness level shown in the System Tray widget and the brightness OSD. (Christoph Wolk, KDE Bugzilla #523281)

Transition times for the Night Light feature are now shown correctly in the Brightness & Color widget when Night Light is configured to be always on. (Vlad Zahorodnii, powerdevil MR #678)

Plasma 6.7.6

Fixed a bug that could occasionally make KWin crash when you returned to a game using Alt+Tab. (Vlad Zahorodnii, KDE Bugzilla #510116)

Fixed a focus-related regression with Wine windows. (Vlad Zahorodnii, KDE Bugzilla #525590)

The Clipboard widget no longer disappears from the System Tray when its panel is over 100px thick. (Tomáš Hnyk, plasma-workspace MR #7048)

Plasma 6.8

Fixed a bug that could sometimes make KWin crash when interacting with titlebar buttons in very specific ways. (Vlad Zahorodnii, kwin MR #9926)

Fixed a very weird bug that could make Plasma hang on login when the computer was connected to a monitor with a non-standard VCP range, such as the Samsung Odyssey G60SF. (Marco Martin, KDE Bugzilla #525216)

Deleting three or more items at a time from the Menu Editor app no longer makes it crash. (David Edmundson, KDE Bugzilla #525598)

Unit conversions in KRunner-powered searches now work in French. (Tobias Fella, KDE Bugzilla #510873)

Plasma 6.9

When Plasma Browser Integration sends a notification about files downloaded using a Firefox-based browser packaged as a Flatpak, the file path that it shows is no longer garbled. (Bharadwaj Raju, KDE Bugzilla #524384)

Made Plasma Browser Integration more robust at exporting album art from a compatible browser to the Media Player widget. (Takashi Kashiwagi, KDE Bugzilla #514788)

Fixed a subtle incompatibility between Plasma’s Edit Mode and the popular Conky system monitoring widgets. (力文 胡, KDE Bugzilla #525792)

Notable in performance & technical

Plasma 6.8

Plasma no longer writes to a cache file every single time it displays a notification. (ValdikSS, KDE Bugzilla #523805)

How you can help

KDE has become important in the world, and your time and contributions have helped us get there. As we grow, we need your support to keep KDE sustainable.

Would you like to help put together this weekly report? Introduce yourself in the Matrix room and join the team!

Beyond that, you can help KDE by directly getting involved in any other projects. Donating time is actually more impactful than donating money. Each contributor makes a huge difference in KDE — you are not a number or a cog in a machine! You don’t have to be a programmer, either; many other opportunities exist.

You can also help out by making a donation! This helps cover operational costs, salaries, travel expenses for contributors, and in general just keeps KDE bringing Free Software to the world.

To get a new Plasma feature or a bug fix mentioned here

Push a commit to the relevant merge request on invent.kde.org.

Made it to Graz for Akademy 2026. Looking forward to meeting my fellow gearheads. In the meantime, let’s go for my web review for the week 2026-38.

25 Years of Mass Surveillance Is Enough

Tags: tech, surveillance, politics, democracy

This essay is fairly US centric but since other countries used the US surveillance apparatus as a blueprint for their own it’s widely applicable. It’s 25 years of failures and constitutional hazard, maybe it’s time to finally respect the right to privacy? Or are our governments too hooked to controlling the population and hunting dissent?

https://www.lawfaremedia.org/article/25-years-of-mass-surveillance-is-enough

What kind of Software should we fund?

Tags: tech, foss, fundraising, supply-chain, ethics, business

The article it refers to is interesting as well of course. Still it shines a crude light on the biases it has. We might have a way to fund libraries available via registries. That’s a good thing… But it ignores a lot of what Free Software is about. We need solutions for more software than just a specific family of libraries.

https://tante.cc/2026/09/17/what-kind-of-software-should-we-fund/

Inside ‘Project Lily’: The Humans Reading Your ChatGPT Chats

Tags: tech, ai, machine-learning, gpt, surveillance

Of course unsurprising. Still it’s important to get the proofs out.

https://www.404media.co/inside-project-lily-the-humans-reading-your-chatgpt-chats/

‘Doom Loop’: OpenAI and Microsoft Admits LLMs Are Destroying the Web and Built on Theft

Tags: tech, ai, machine-learning, gpt, ethics, copyright

They claim fair use in public court but they know full well what they’ve been doing.

https://www.404media.co/doom-loop-openai-and-microsoft-admits-llms-are-destroying-the-web-and-built-on-theft/

Be alert: targeted attacks on prominent Rustaceans

Tags: tech, rust, supply-chain, security

Bad actors clearly want to compromise supply chains. Stay safe and keep your eyes open.

https://blog.rust-lang.org/2026/09/17/targeted-attacks/

what if my git host were a static site generator?

Tags: tech, tools, git, self-hosting

Looks like an interesting tool to expose git repositories read-only on the web.

https://char.lt/blog/2026/09/sorcery-repo-viewer/

A Design Space Exploration of Async/Await

Tags: tech, asynchronous, reliability

You think async/await works in the same way across languages? Think again! There are several choices of implementation behind it. You better know which choices your particular runtime did, otherwise you will get surprises. It also means it’s harder to reuse language from a given runtime and carry it over somewhere else.

Of course I recommend reading the full paper, but this short summary gives a good idea of the content.

https://cel.cs.brown.edu/blog/design-space-async-await/

How fast is C++23’s std::flat_map?

Tags: tech, c++, data, performance

Indeed it’s a very good new type of maps in many cases. Again a good illustration that nowadays memory layout is often more important than algorithmic complexity.

https://lemire.me/blog/2026/09/16/how-fast-is-c23s-stdflat_map/

C++26: Trivial infinite loops are no longer undefined behaviour

Tags: tech, c++, reliability, safety

It’s about time that it got fixed… This was really a language defect.

https://www.sandordargo.com/blog/2026/09/16/cpp26-trivial-infinite-loops

How to Recognize a Change in Capacity to Stop Pressure

Tags: management, productivity

Doesn’t feel too actionable on how to detect the change of capacity. That said the advice on how to deal with it is correct.

https://www.jrothman.com/mpd/2026/09/management-minute-how-to-recognize-a-change-in-capacity-to-stop-pressure/

Clear as Mud

Tags: management, delegation

A few things to keep in mind when delegating tasks. This seems trivial but it’s harder than it sounds.

https://managementblog.org/2026/08/28/clear-as-mud/

Proper English is a Myth: There’s No ‘Correct’ Way to Write

Tags: linguistics, writing

I’d say it goes a bit too far in its stance at times. That said it’s a good reminder that English like any other languages is in a constant state of flux.

https://brennan.day/proper-english-is-a-myth-theres-no-correct-way-to-write/

Bye for now!

In the earlier blog posts about Qt Canvas Painter we have looked at what it is, the new rendering features it brings, how fast it is compared to QPainter, and how path caching makes even a million line segments render smoothly. All of those earlier blog posts used the QCanvasPainter C++ API. At the end of the path caching post I teased that a QML element was coming, and it is here now: Canvas2D, available in Qt 6.12.

About Block Editors

A block editor is an easy to use rich text editor which treats every component of your text as a block. You may be familiar with apps like Notion and the editor you see there is exactly that. A block editor allows you to easily re-order your components and make your editing workflow feel more interactive. Most block editors that you will see online support a subset of CommonMark’s features such as headings, lists, quotes, and tables which makes editing even more seamless.

Why?

Traditional text editors feature one continuous text field for you to write down content. This is fine if you need simple formatting and do not need frequent rearrangement. However, if you need structured and extensible content, reusable components, easy rearrangement, and better pragmatic control, block editors are an excellent choice.

Marknote has been a popular note taking app for Linux for a few years now. It supported a subset of Markdown in edit mode and Qt’s built-in markdown parser that’s present in the TextArea QML component to load markdown files. This means that markdown parsing was handled in two separate ways, when you launch Marknote, Qt’s built-in markdown parser would render the content, but when you edit the document in real time, a bunch of pattern matching rules decided how to auto-transform the current text into formatted text. For example, rules like “Is the current word surrounded by asterisks (*)?”. These rules worked fine for simple use cases, but they introduced unhandled edge-cases and were very hard to extend and maintain.

Marknote’s New Block Editor

This is Marknote’s new block editor. It supports the full CommonMark spec, powered by KDE’s new markdown parser known as md4qt . It supports everything you might expect from a markdown editor and more. You can drag-and-drop component anywhere you want. It features an easy to use command prompt which you can invoke by pressing slash (/) on your keyboard. You can see it in action in the video above.

Challenges

Implementing this block editor was challenging yet fun. The first challenge was to render nested components in QML. This challenge and how I solved it is described in detail here . After this, I was able to easily render markdown documents using nested QML components. The next challenge was to allow editing those blocks.

Editing Blocks

MD4Qt parses markdown in the form of abstract syntax trees (ASTs). You can traverse the tree, modify it, or delete nodes from it. What I needed was a way to edit the text content. When you edit a block in realtime, parsing its markdown content on every keystroke is not a good idea because of potential performance issues. This is why, the block editor is implemented this way: you will see the raw markdown of the paragraph block you’re currently editing. Only when the current block goes out of focus (by switching to another block or pressing Esc), the content will be parsed. This means you can paste an entire markdown document in a block and it will easily expand into blocks as if you had pasted actual blocks! Auto transformation for blocks based on very simple rules is still present. For example, you can create headings by pressing one or more times # followed by a space. These are only a handful of rules so there aren’t any edge cases.

Implementing Tables

Tables are very complex in nature. Each table has multiple rows and columns, which means multiple text fields. I took inspiration from other block editors here. Each table is just one block. It can not have nested blocks inside it. This made it easier to implement them. In the old editor, tables were very simple. They didn’t have any controls to delete or modify rows. Since each component here is designed in QML, I had a lot of flexibility in how I want the tables to look and be controlled. So each table now has buttons to insert and delete rows and columns. I’ll soon also add the ability to drag and drop table columns and rows.

Drag and Drop

The next challenge was to implement drag-and-drop. Since markdown can become complex with its nesting features, I needed a way to make sure it feels very natural. The most important thing was to place the drag handle in a place which does not make it look awkward. Since blocks can be nested, each nested block had to have its own drag handle. Most block editors either don’t support nested blocks or the ones which do, do not allow dragging them when they’re nested. I wanted both, so after many trials, I made the handles invisible at first. When you hover over a block, you will see its drag handle, and when you hover over the drag handle, the entire block shifts a little towards the right, clearly indicating which part of the block you’re about to drag (which is essential to know here because of nesting). I immediately liked this way of doing it so I stuck with it. Implementing the remaining logic was pretty straightfoward with QML’s DropArea and DragHandler elements.

Fixing Existing Features

Marknote had a good list of features implemented by many different contributors, for example, search and replace, a table of contents drawer, source mode, GUI formatting controls, internal note links, and an emoji picker. These are strictly tied to the old text editor. Fixing them required understanding the old code and making them work with the new editor. For some features like search and replace, I had to go with workarounds due to lack of enough time. Searching within the block editor works as intended, however, when you open the replace field as well, you will be moved to the source mode which contains the raw markdown of the file. I have plans to change this behavior in the future, but it does the job for now.

Conclusion

This project was part of my Google Summer of Code 2026 project. I had a lot of fun implementing it and learned a lot. I’m very grateful to my mentors Carl Schwan and Mathis Brüchert for their support in the development of the block editor. My plans are to continue working on Marknote to make it the best note taking app on Linux. I’m also involved in other KDE projects such as Drawy and am planning to contribute to Plasma as well as I recently switched from Hyprland to KDE Plasma and have been loving the convenience it provides. I believe the KDE ecosystem is the future of Linux and I want to contribute to it as much as I can. Thanks for reading this blog. As always, no AI was used to write this blog and all words are my own.

Every C# UI framework comes with a familiar pattern: Windows-first, Linux absent, roadmap uncertain. WPF stalled, MAUI skipped Linux, WinUI 3 stays Windows-native. At the same time, demand for embedded Linux grows and C# teams feel the lack of good UI alternatives for C# on Linux. Qt Bridges, a bridging technology in public beta for C#, provides access to a UI framework that allows preserving your existing C# codebase while utilizing Qt Quick’s feature-rich UI libraries and APIs, hardware acceleration, and cross-platform capability.

Happy to announce a new version of Kirigami Addons, as well as the first version of my new app: Imprint.

Kirigami Addons is a collection of many useful modules for your QML and Kirigami applications, and Imprint is a new PDF editor.

Let’s start with the more user facing of the two.

Imprint 1.0

Imprint is a very basic PDF editor. Right now it allows you to merge multiple PDFs together; re-order, remove or delete pages; and add or remove password protection.

There are also ways to modify a single PDF page, by for example cropping it.

Or adding basic annotation:

Additionally, all actions made in Imprint are based on commands which are undoable.

On the technical side, I use both Poppler and QPDF. Poppler is used for rendering the PDF, and QPDF is used for editing the raw PDF. The annotations for the editor use the new QtCanvasPainter module from Qt, which is great as it allows moving most of the code to C++.

For now, this really provides the foundation of a powerful PDF editor and in the future I hope to be able to come near feature parity with proprietary apps like iLovePDF. I expect as always to release another version soon with a lot of bugfixes :)

Kirigami Addons 1.14.0

As always when working on a new application, this is the occasion to improve Kirigami Addons even more :)

FormCard

The FormCard modules received a new component FormDelegateCollapsible contributed by Robert French. As the name indicates, it allows you to make a section of a FormCard collapsible.

Another improvement is that any FormCard delegate can now be injected into a FormGridContainer.

FormCard.FormGridContainer {
 FormCard.FormButtonDelegate {
 text: "Open"
 description: "Open a document"
 }

 FormCard.FormSwitchDelegate {
 text: "Enable sync"
 }
}

Since KAboutData was extended with more data that application developers can provide, the AboutPage component was also extended in terms of the data we display to the user.

We now support Mastodon and Matrix links, and when clicking on the application name, we display the changelog.

This module also received numerous performance improvements based on the results of qmlprofiler and I did some internal refactoring to take advantage of newer Qt/QML APIs (e.g. LayoutItemProxy).

Actions

The actions modules of Kirigami Addons also received numerous updates to cover the cases of a document editor like Imprint. The biggest change is that there is now a QML API in addition to the existing C++ API; that there is a way to define and render menus; and a way to add context to an action, so that a group of actions is enabled or not depending on a state (e.g. document open, document modified, one page selected, multiple pages selected).

Packager section

You can find the package on download.kde.org (kirigami addons) and it has been signed with my GPG key.

For Imprint, it is for now a personal project not part of KDE, and you can find a tarball (checksum: 1b44d0f138ac175dc13cb00cef5740336f006b2a4dd4737266938278408bd34f) on this website and it is also signed (checksum: 70073cb71f970e94a5d3c7dd4dba6dc5c17a0d19b331a1556e739dc91f748994).

Akademy 2026

I am also going to be at Akademy, but this time only for the weekend as I am afterward taking the sleeper train on Sunday evening to get back to Berlin in the morning for the Nextcloud Community Conference.

As part of the on-going development of Qt Bridges, and beyond the two Beta versions already released, we've continued to add new features to the C# bridge, and we're now announcing the release of a new Beta version 0.4.0. The highlight of this release is the possibility to develop C# + QML applications without the need for a C++ compiler. This means that C# developers can now take full advantage of Qt’s UI framework capabilities while keeping their familiar development workflow. Other features that we've added in this release include support for macOS and Windows on ARM.

The past couple of weeks moved on to the other half of the editor work- the kded dialogs that pops up on NetworkManager's behalf - the secret prompt, the SIM PIN dialog, the mobile broadband wizard.

Why this needs doing

The Connection Editor isn't the only place libs/editor gets used. kded's network management module runs as NetworkManager's secret agent: whenever NetworkManager needs a password, a PIN, or a fresh mobile broadband connection, it asks the agent, and the agent has been popping up a QDialog ever since. PasswordDialog asks for Wi-Fi/PPP/VPN secrets, PinDialog unlocks a SIM, MobileConnectionWizard walks through adding a GSM/CDMA connection when you plug in a modem or pair a Bluetooth phone for DUN. All three are widgets, and the VPN half of PasswordDialog reuses the same VpnUiPlugin-returning-a-QWidget mechanism the editor already moved off of.

The straightforward half

The new module is kdedqml, structured the same way editorqml was: a small set of QObjects and a PromptWindow that hosts whichever QML file they back.

kdedqml/
├── passwordprompt.cpp / .h    secrets for a plain setting or a VPN
├── pinprompt.cpp / .h         SIM PIN/PUK unlock
├── mobilewizard.cpp / .h      GSM/CDMA connection wizard
├── promptwindow.cpp / .h      hosts one QML file + one backing QObject
└── qml/
    ├── PasswordPrompt.qml
    ├── PinPrompt.qml
    └── MobileWizard.qml

PromptWindow is the one new idea here, and it's deliberately dumb - give it a QUrl and a QObject, and it loads the QML file into a QQmlApplicationEngine, exposes the object as a context property named prompt, and shows the window. Every one of the three prompts is just "construct the backing object, hand it to a PromptWindow":

m_promptWindow->show(QUrl(QStringLiteral("qrc:/plasma-nm/kdedqml/qml/PasswordPrompt.qml")), m_dialog);

PasswordPrompt itself does the boring 90% of the work first: it duplicates what PasswordDialog already did for plain secrets (Wi-Fi retry messages, WEP/WPA key validation via NetworkManagerQt rather than a regex, the same rule as last time) and, for VPNs, reuses the AuthSetting classes the editor already has:

if (shortName == QLatin1String("ssh")) {
    m_vpnAuth = createAuth<SshAuthSetting>(hints, this, vpnSetting, m_vpnSecrets);
} else if (shortName == QLatin1String("sstp")) {
    m_vpnAuth = createAuth<SstpAuthSetting>(hints, this, vpnSetting, m_vpnSecrets);
} ...

createAuth constructs the setting and calls loadSecrets(), just pointed at secrets instead of full config. Ten VPN types wired up this way, and PasswordPrompt.qml picks the matching Auth.qml from the editor with a Loader switching on service type, exactly like the editor's own VPN page switches on it.

The half that is actually interesting

OpenConnect doesn't fit that shape at all, because it was never really a settings-and-secrets dialog. The widget version, OpenconnectAuthWidget, runs a whole login session: it drives libopenconnect on a worker thread, and the C library calls back into Qt synchronously to ask for a login form, validate a server certificate, or open a browser for single sign-on - and it expects an answer before it returns, because it's still in the middle of openconnect_obtain_cookie().

The trick the widget uses, and the one I had to keep, is that the callback doesn't wait on the GUI thread's answer via a blocking Qt connection. It emits a signal, then blocks itself on a QWaitCondition:

int OpenconnectAuthWorkerThread::validatePeerCert(void *cert, const char *reason)
{
    ...
    bool accepted = false;
    m_mutex->lock();
    Q_EMIT validatePeerCert(qFingerprint, qCertinfo, qReason, &accepted);
    m_waitForUserInput->wait(m_mutex);
    m_mutex->unlock();
    ...
}

The worker thread is asleep inside wait(), so the bool *accepted pointer it handed across threads stays valid for however long the GUI takes to answer - which for a modal QDialog::exec() was instant, but for a QML dialog the answer only comes back later, from a separate button click. So OpenconnectAuth (the new QML-facing class) splits every one of these callbacks into two halves: the slot that receives the signal just records the state and returns immediately, and a separate Q_INVOKABLE - acceptCertificate(), submitForm() - does the actual wakeAll() once the user has answered:

void OpenconnectAuth::acceptCertificate(bool accept)
{
    *m_certAcceptedPtr = accept;
    ...
    m_mutex.lock();
    m_workerWaiting.wakeAll();
    m_mutex.unlock();
}

Everything else - the dynamic login form built from oc_auth_form, the "changing the group re-submits" behaviour, the SSO web login - is the same worker thread, copied unchanged, talking to a QML WebEngineView instead of a QWebEngineView widget. The two share the same underlying Qt WebEngine types (QWebEngineLoadingInfo, QWebEngineCookieStore, QWebEngineWebAuthUxRequest), so the bridge is mostly mechanical - a WebEngineView.onWebAuthUxRequested handler calling straight into the existing OpenconnectWebAuth helper from the editor's SSO work.

Wiring it together

secretagent.cpp picks between PasswordDialog and PasswordPrompt with a type alias behind HAVE_KDEDQML, so the rest of the file barely changes:

#ifdef HAVE_KDEDQML
using SecretsPrompt = PasswordPrompt;
#else
using SecretsPrompt = PasswordDialog;
#endif

The one real change is that closing a prompt used to be m_dialog->deleteLater() scattered across cancel, reject, and kill paths; those all go through one closePrompt() now, which also closes the shared PromptWindow if there is one. bluetoothmonitor.cpp and modemmonitor.cpp get the same treatment for the mobile wizard and the PIN dialog - and the PIN one loses something along the way: it no longer calls QDialog::exec(), so unlocking a SIM doesn't block kded on a nested event loop anymore.

OpenConnect gets one more property on top of that, selfDriven, because the worker thread accepts the dialog itself once it has a cookie - there's no Ok button to press, only Cancel:

standardButtons: prompt.selfDriven ? QQC2.DialogButtonBox.Cancel : QQC2.DialogButtonBox.Ok | QQC2.DialogButtonBox.Cancel

Same BUILD_EDITORQML flag as before, just gating one more directory now.

What is left

The mobile broadband wizard, PIN prompt, and OpenConnect are all wired up now. What's left is test coverage for the new kdedqml classes, and the actual port to Plasma Mobile, since PromptWindow and the three prompts were built with a phone-sized layout in mind but haven't been run on one yet.

HAVE_KDEDQML and HAVE_OPENCONNECT both mean the widget path is still there, on purpose - nothing gets to come out until the QML path has actually been exercised end to end, tests included. And this was only the kded side; the applet's Handler::showConnectionEditor() still opens the widget ConnectionEditorDialog directly for WPA-Enterprise networks it can't join with a password alone, which is the other loose thread from last time and still isn't pulled.

Thanks, see you soon.

It’s been 7 years since I last posted such a banner, and just today I remembered how I was always excited about this kind of posts, so here we go. I’ve also been to Akademy in W√ºrzburg 2 years ago, but didn’t post the banner for some reason (silly me!).

I haven’t really contributed to KDE for quite a while, but Akademy is always worth attending, even just to meet old friends again and make some new ones. Plus this year is KDE’s 30th birthday. KDE has been such a huge part of my life, so I am not going to miss such an anniversary.

Can’t wait to see you all in Graz soon!