In 2013 I bought an Ubuntu Phone. Not because I needed a new phone, but because the demos kept showing one specific thing: plug the phone into a monitor, and it became a desktop. Same device, same apps, no second OS. I wanted that to be real.

I didn't just buy one. I was twenty, and I started writing to OEMs and ODMs, asking for datasheets and reference devices, half-convinced I could port a convergent shell onto something I'd eventually sell. What I got instead was a crash course in why phone hardware is the way it is. Halium kept me alive on a handful of devices, but most of the time I was fighting opaque binary blobs, vendor kernels frozen on branches nobody had touched in a year, and OEM support that was technically polite and practically absent. The hardware ended up unmanageable, the optimizations I wanted were impossible to land, and the plan died there — but that was the period where I learned the most about how things actually work below the application layer.

The dream itself didn't fare much better. The Ubuntu Phone dock was sluggish on the hardware I had, app support was thin, and the whole thing felt like a bet the market wasn't ready to take. Canonical folded Ubuntu Touch a few years later. UBports kept it alive. Lomiri inherited the convergence ambitions with a smaller community. I never stopped paying attention.

That makes thirteen years.

What convergence actually means to me

The word "convergence" has been worn smooth by marketing slides. Most people, when they hear it, think of responsive design for applications. That isn't the interesting part. The interesting part is the shell — the thing that draws the dock, the status bar, the window decorations, the lock screen. The shell is where computing meets your hands.

On Linux today, every shell is locked to a form factor. Plasma assumes a desktop. Plasma Mobile assumes a phone. GNOME assumes a laptop. Phosh assumes a phone. Each of them does its thing well, but moving between them means moving between sessions, sometimes between distros.

What I've wanted since that first Ubuntu Phone is a single shell that knows what it's running on, and quietly rearranges itself. Plug a monitor in: dock at the bottom, edge tiling, system tray. Unplug it: the same processes, the same notifications, laid out for thumbs.

Why Plasma Mobile

I tried writing this from scratch a few times over the years. Every time, I got far enough to realise how much I was about to reinvent, and stopped.

Plasma Mobile already does the hard part. It's a Plasma shell, written in QML on top of kwin — the same compositor that powers Plasma desktop. It speaks Wayland correctly. It has an action drawer, a homescreen, a status bar, KWin scripts to manage windows. The phone side is solid.

What it was missing is the desktop side. So I forked it.

What SHIFT is

SHIFT is a fork of plasma-mobile at the KDE Plasma 6 branch. If you boot SHIFT on a phone, it behaves like Plasma Mobile — the upstream phone UI is untouched. The fork adds a convergence mode, a layer on top, toggled through plasmamobilerc. When the device is docked or running on a desktop screen, SHIFT swaps in different behaviour without replacing what's underneath.

That decision was deliberate. I didn't want to rewrite the homescreen in a desktop style. I wanted the same homescreen to act differently when the context changes. The convergence work sits alongside the existing components, not instead of them.

In concrete terms, here's what convergence mode currently does:

• The mobile navigation panel is replaced by a dock with running-app indicators, favourites, hover tooltips, and a context menu for pin and unpin.
• The app drawer opens as a centred popup above the dock instead of a full-screen swipe.
• KWin scripts enable edge tiling, edge-maximize, close buttons on titlebars, and Overview integration.
• The status bar grows a system tray, a date display, and hover highlights.
• The dock reserves screen space through a layer-shell exclusive zone, so maximized windows don't slide under it.
• Hovering a dock icon shows a window thumbnail, captured through PipeWire screencasting.
• Right-click a running app to pin it to the dock. Right-click the wallpaper for settings. Press home to minimize everything.

None of this is groundbreaking on its own. Every desktop has had a dock for thirty years. The work is in making those behaviours coexist with a shell originally designed for a 5-inch screen, without forking the QML codebase in two.

What it isn't

SHIFT is not a distribution. It's not a competing project to Plasma. It is not affiliated with or endorsed by KDE. It's a personal fork of an existing KDE project, with a specific focus, published under EUPL-1.2 for the new code, while upstream files retain their GPL and LGPL licenses.

It also isn't finished. The first commit that mentions "convergence mode" is from 2026-04-08. Roughly three weeks of evening work. The desktop demos run, the dock looks like a dock, the tiling works — but plenty of recent commits are about null guards in AppletHost, a dangling pointer in the flashlight helper (yes, the flashlight helper had a dangling pointer), and CI lint failures. The kind of bugs you only find by actually using the thing.

Where it goes

The roadmap, such as it is:

1. Stabilize the desktop mode. Most recent commits are bug fixes. There's still work on multi-monitor behaviour, Overview ergonomics, and tiling shortcuts.
2. Tablet mode. Plasma Mobile already handles touch correctly. The interesting part is the in-between — a convertible laptop that flips, a tablet docked to a keyboard. Those should be smooth transitions, not separate sessions.
3. Game shell. This is the long-term thing. A controller-driven layout that lives in the same shell binary, the same QML codebase, the same KWin policies. Steam's Big Picture is the shape; I want it to feel like part of the system, not a mode you launch into.

The pitch isn't "Plasma Mobile but better". It's "what if Plasma Mobile was the seed of a shell that doesn't decide what device it's on until it asks". That's what I've been building, evenings and weekends, since early April.

Why now

If you're reading this and wondering why this is publishable now and not three years ago — because the substrate is finally good enough. Wayland is the default on most distros. kwin 6 has stable scripting APIs. PipeWire makes screencasting a normal thing instead of an X11 hack. KAuth runs without ambient root. Layer-shell is a real protocol with multiple implementations. The bricks I would have had to make myself a decade ago are sitting on the shelf.

The repo is at code.marcoallegretti.me/marcoallegretti/shift-shell, mirrored from KDE Invent. Issues, ideas, and harsh code review are all welcome.

Thirteen years of paying attention. Let's see if the third try sticks.