hckrnws

I've tested everything. Xfce, tiling window managers, kde. Eventually I settled on Gnome, but I incorporate few "tiling features". Such as keystroke changing workspaces on one monitor and the second monitor always showing the same few "always on" apps.

I always have my terminal with tmux full screen on workspace 1. My Web browser on no 2. My IDE on 4 and my password manager on 9. Then if I watch a video it's always on 3, if I do graphics work it's always on 5 and so on.

I use ctrl-super-number to switch workspaces. If I need to move current window it's ctrl-shift-super-number.

On a work windows mashine I use the exa t same keys thanks to AutoHotkey software. So I have the exact same work flow on Linux and Windows. The only difference is on Windows workspace 1 is WSL terminal.

Ive been working like this for years. Select copy and paste works fine with left/right mouse button.

I have all my widgets I need showing the temperatures, what my pc and network are doing.

Why would I want to change anything?

All the other changes I see are just shuffling around the UI, which doesn't really help anyone. And even newer features are either so marginal as to not matter, or can't be trusted to stick around. Why bother to learn a new UI, when all that does is get you back to square 1, and it might not even stick around? I'd be much more interested in tweaking my DE if I could be confident in knowing that those tweaks will persist and not cause other problems down the line, but I have no such assurance.

I don't blame the casuals for hating UI updates. I myself went to Linux to get a more cohesive and stable experience. If we're going to make changes, we need to not break workflows that already exist. New features and workflows need to either not be in the way for established users, or opt-in until they're established and known good. Doing anything else is user hostile, and by this time, given how much we know users don't like changing UI, dare I say, evil.

Many of us solve our UI problems and we land into our own happy minima.

Many of the UX "solutions" are either invented problems or not my problems or worse, grinding some anti-me agenda.

Like many, a lot of my UX improvements have been to simplify the UI. Tiling, with just a few windows per virtual desktop in herbstluftwm: kitty, emacs, browser and some rare transient application (usually PDF or image viewer).

The idea in the screen shot horrifies me. Why would I buy an expensive high pixel monitor just to use only 10% of it to display a single window? Why would I want to waste CPU to animate the migration of a full window to a single button icon (another example given)?

These UI "innovations" are great for movie props but do they actually help in reality? Not that I see. The "stagnation" of UI to me is more a plateau. Anything truly new must be driven by new "I", no input/output channels between user and computer.

The one interesting idea I saw in the article was Lifestreams. I think storage and recall is something that needs improvement and new ideas because for me that is a problem. I produce and consume too much info while recalling it is hard and while also I often do not produce or consume info that I wish I had.

Again, it's the I/O that drives the progress.

Here's an idea that I believe I read in HN as "the original purpose of the desktop": add a Desktop Manager that manages which icons are on your desktop and makes it easy to switch.

The desktop is kind of weird, in the sense that it's prime real estate but, at the same time, there's an expectation that you shouldn't put too much stuff there, and then it ends up cluttered anyway. I think it's worth trying a stronger separation between "Desktop" and any other regular folder, emphasizing that the Desktop is where you place links to the files you need right now, but with a mechanism to clear it completely (without losing data) and another to switch which icons you see right now, kind of like browser tab groups. That way, when you're working on a project you place the files you need on the desktop and when you're done you clean it up.

Yeah, this can be a little extreme, and I feel we can benefit from being a little more open to trying new things.

The part about designing specifically for large displays and widescreen monitors was interesting. We can also reverse it, though: right now I'm away from home, and I only have this old laptop which is mostly great but has a shitty touchpad as the mouse, and I have to think this must be really common. However, this situation seems to be completely ignored by all desktop UX design. We seem to be pretty good at coming up with ways to use the mouse in our programs, but when the mouse is hard to control and unreliable, it causes pain. I guess I can use ratpoison or something, but that seems to be giving up too much.

Regarding the AI going deep into the filesystem and organizing my data...I'm extremely skeptical of inserting any kind of inherent unpredictability into how I interact with the computer. Giving a command or input should produce a well-defined and predictable (in principle) action. Getting rid of that paradigm fundamentally changes the relationship between the user and the computer in a way that, in my opinion at least, greatly diminishes its usefulness as a tool.

That is really the direction of "UX" I'm interested in. Not so much about where to display what, but to make my computing device feel less like an accumulation of applications and data, but to have a more integrated experience, ideally even across devices. My laptop and phone barely talk to each other and the user account on each device is distinct, so sharing resources already fails on authentication not being solved.

I think open source is in a unique position to actually provide a much better UX than any proprietary computing environment, since it's not tied to a single company trying to sell you stuff. Gnome and KDE don't care where you store your emails or calendar, they don't want to upsell you into their cloud storage. Open source is free to integrate the best services in a way that has the best UX and it can even do things like sync directly between your devices, because it doesn't need to generate new business opportunities.

Many people don't use a clipboard manager at all, and even what exists today would be a huge upgrade for anyone accustomed to only a single clipboard "slot" that's instantly overwritten the next time you copy anything. Windows has one built in (though turned off by default), KDE Plasma ships with one, MacOS has third-party ones IIUC (not a Mac myself).

But imagine a clipboard manager that wherever you hit Ctrl+C also simply grabs the title of the active window and a deep link/URI that points to the cursor's current location (if a browser then it would be a URL, if a local program then some kind of local file:// URI). If you want to be really fancy, snap a screenshot too (maybe make this opt-in both for privacy and screenshot storage size concerns).

Then, whenever you pull up your clipboard history, a) it reminds you where you grabbed whatever text or image or document etc. that is, and b) with one click you can navigate back there.

I think we might get something like half of what Scott is talking about with "working memory" by adding this one affordance to existing clipboard history paradigms.

Many of my frustrations today come from the sharp line between apps and OS. Apps have custom storage formats, custom UIs, and custom settings, and that makes it difficult for a user to deal with their data holistically. Even something as trivial as searching across all my data is not a solved problem, and that's because every app has a different way of representing data.

But what is an app? An app is just a UX/UI on top of a data model with domain-specific rules for transforming that data. What if we could decompose those pieces: the UX is just a custom control; the data model can be represented by a standard database; the domain-specific rules can be a headless component.

The decomposition gives the user more control: all my data is in a standard database. I can drive headless components via script or agents. And I can compose my UX based on my preferences instead of how the app decided to package it.

(link timestamped to 29min, where the demo starts.)

It's also a perfect use for local System One models that can classify prompts and forward them to the right module - calculator for math, distrobox for shell commands, LLM for natural language questions and normal search for everything else. Not using a fixed classifier because plugins should be able to add their own question types.

The article mentioned WinFS and relational filesystems. That's another good idea, integrate metadata so you can support use cases like finding all pictures of your dog or all playlists with Ed Sheeran songs (to remove them). Everything bound to the file entries instead of ID3 tags inside the file or app specific databases. It would be a lot more reliable and probably faster.

IIRC bcachefs is already a relational database but I don't know how good the query APIs are. If we can't do full extendable tags then at least add user defined groups/tags like Work and Games and Photos to make finding things easier. People remember what a file is better than where it's stored.

Meanwhile it's been years since KDE Connect allows devices to talk to each, sending SMS on desktop from phone, pausing phone podcast from desktop, sharing files from XR headset to desktop, etc.

A lot could be improved but the modern open-source desktop is already doing great.

True revolution in UX will come from making customisation accessible, so everyone can decide what's best for them without losing their minds in endless customisation rabbit holes or having to rely on big and clumsy organizations.

In 2004, the Eclipse IDE established consistent UI guidelines, built upon a cross-platform GUI library. API desgin is great, Looks and feels robust. The future of desktop GUIs looked bright. Little did we know that 25 years later it would turn out to be such a disaster.

But for those who want to experiment, I've seen: - Tiling window managers (I3, Awesome, etc) - Highly customizable panels and launchers (Rofi, Lemonbar, etc) - Scrolling window managers (Nori, and others I think)

Honestly, the linux desktop has a lot of criticisms you could level at it, but lack of innovation isn't one. Where Windows and Mac have agreed on a standard that hasn't changed much in the last 10 years, Linux has about a zillion different visions for what a desktop can be.

Still, I do think that it is possible to improve things. I would like to have the UNIX philospopy of simple tools that interoperate translate GUI tools. And then I want a networked window system where programs can interoperate across machines and where windows can moved between them. I want to move the window from my cell phone to my desktop and then drag a file from my camera into an email, etc. X can do this in principle, but these capabilities where never really exploited by the Linux desktop. The always just tried to copy MacOS which is a bit sad.

What I do find is really lacking is UX inside of many foss apps. So many of them feel like windows xp programs with toolbars that look like junk drawers.

The biggest problem with UX developers is they know better than you AND force you into their paradigm. They came on the scene and decided "Choice is Bad" coupled with "Our way or the highway".

I've decided to be frozen in time with MATE (basically gnome 2). I have problems with it, but I've realized I don't want to be hit with surprise! on upgrades.

Wow, the exact person I don't want designing anything I work with. Go away.

We tried that! It works great on small screens that you poke with your finger. And it made Linus himself switch away from Gnome for a while.

My dream UX would be one with the consistency and customisation of the past. Both Gnome 2 and Win 95 (and 3.1) had title bars of the active window a different color to inactive ones, you could even change the accent color to yellow.

Title bars were much more consistent than now - I don't need individual applications to decide whether they want to put the close button on the left or the right of their custom-styled frame. (To be fair, MacOS is still fairly consistent.) It's like each programmer decided whether their application would use light mode or dark mode rather than leaving the choice up to the user.

This is one of the times when "less is more".

I used an actual NeXT workstation for 8 months as my only desktop in the mid 1990s and it was the most integrated and best GUI I’ve ever used.

I hope Scott keeps spreading the good word and inspiring others to take different perspectives

And it always will be, because "users" is plural. It is not a defect in the design of the desktop or whatever has "too many" alternatives. The mistake would be to think that "one-desktop-fits-all".

Also, the only good reason to change things is to fix problems. Nobody's really asking for "moar modernity". Starting from design theories is plain wrong. Ask users about their problems first, and the use your design knowledge to analyse and fix them.

> Strategy is another part of UX; understanding who the target user is, and determining what they want. Deciding what is important, and what is not; what will the development team prioritize and what will it ignore? "The fastest way a UX designer can save your team time is to help you say no."

He is not talking about users but customers.

That's how FOSS works: some users find it annoying to have to place and resize their windows manually, so some of them made "tiling window managers". Many Linux DEs also had virtual desktops a million years before Windows because FOSS is made by users, for users.

The problem is that this doesn't really fix the underlying issue, which is the bozo explosion of footguns in the UI itself. In fact, it just papers over all the problems.

A good UI needs to be opinionated. And also, getting rid of cruft is at least if not more important than building any new feature.

I feel this so much.

I think that there's a "better" windowing system where all of your stuff sticks around way more than it used to. Clipboard history, but also just "oh you have these windows open while working on this task".

People have really leaned into coding harnesses + chat windows as a way of grouping together work. I think there's a more general idea in this space. Don't make me explicitly keep track of things, just hold onto it all for me!

There's some universe where my desktop is basically a Notion-like thing, and I can just throw things into semi-persistent workspaces (that I close out when I'm done). Desktop Environments that make this work nicely will be quite cool IMO

(A simple and dumb version of this is the BeOS "group various windows together, even though they aren't from the same application" stuff. Very cool stuff IMO

https://winworldpc.com/product/dashboard/30

Like, "let's put the buttons at the bottom so the user can reach it with their thumb while holding the phone" got turned into "let's put every important button at the top left where it's literally the hardest place on the whole screen for an average user to reach during typical use".

Or, more importantly, it started out as something like... "Debian/Ubuntu has a rich repository of high-quality full-featured battle-tested popular programs curated by community experts, designed by and for users to empower themselves, so lets give users a way to run all those beloved programs on mobile devices". And then it became "let's get rid of the package repository and forbid users from running anything from it, and build a brand new system which is incompatible with everything, and instead has a commercial app store where corps can sell proprietary software and Canonical gets a big cut of each sale, and the OS has only a small set of proof-of-concept placeholder programs, and is designed to restrict the user so corporate partners can have more profit and control".

And then when it didn't work out, the company kinda doubled down on some of the worst parts of it and went all-in on Snappy.

Instead of bringing phones up to the level of a desktop, as promised... the company tried to bring desktops down to the level of a phone. And that trend has been increasingly popular in the corporate Linux world lately... "Androidifying" desktop Linux.

sigh

I'm tired, boss.

I am fully behind the idea of continual improvement and experimentation. But if KDE ever decides _yet again_ to tear down and rebuild the whole experience from scratch, I swear, I am going to start paying more attention to the intrusive thoughts of my inner pyromaniac.

There's something to this thinking. Large workstation monitors are very much their own thing.

A real example l I've found: Niri (scrolling window manager) is really nice on a laptop but awful on my 6K display. The windows are way too tall, and the induced motion of large windows on a big screen is too much.

But I also think that what we have today in Gnome and KDE is pretty good, and a part of the problem is that people don't realize how good they can be.

I think demo videos showing actual power users doing real work in each of the major DE's would go a long way. Part of the allure of tiling VM's is that they are an efficient way to work for certain types of users, but part of it is that those users are advocates and have impressive demo videos showing exactly how tiling VM's can be awesome, while a Gnome or KDE user is left to kind of figure it out, or worse, discover how they differ from a familiar windows or macos.

(I may be unaware of a great source of exactly what I ask for and if so please tell me!)

[1] https://ii.clsty.link/en/

My wife, whose technical level leans her towards wanting to replace her mac mini when a VPN that she'd installed and then disabled left hostile firewall rules in place ("the internet is flaky on this computer"), is jealous of the tiling setup on my desktop (was hyprland; now sway with a custom dwindle layout). I think tiling has an audience beyond nerds, but I think nobody (perhaps with the exception of omarchy) has made a serious attempt at packaging it in a way that's accessible to business/productivity users. KDE's tiling attempts were, at least last time that I checked, somewhat bolted on and half-assed. I wish omarchy success in de-vibing their codebase, but it would be great to have some serious competition in the space.

Scott is a very good presenter, and he clearly thinks about this stuff a lot. I really liked the demo for moving windows to the sides of the screen, since it's kind of how I use the alt-tab interface -- look at the preview for the window/app I'm looking for then tab to it or click on it. Having a visual overview of all currently open windows could be useful to me. (It might actually get me to close things I'm not currently working on! Although my dozens and dozens of browser tabs tell a different story...)

[1]: https://www.youtube.com/watch?v=V7AfAcQwLW0

Open desktops are like an architect that keeps moving the bathroom doors in a building under perpetual construction. The ecosystem naturally destroys itself every major release cycle, work put into quality of life improvements is lost, and code smell is so terrible people just abandon the projects after it becomes burdensome.

The mistake people make is trying to reason with people about which groups breaking changes take priority. This is why Cinnamon continues to run desktops on systems with broken GPU drivers, and installed as a fail-back GUI plan when Wayland glitches up.

People need to stop telling new users to follow a 15 step CLI tutorial to bring up a broken distribution Desktop. =3

For example: - New terminal: CWD is set to folder - File search: scoped to this folder - Run commands from launcher: dir contents are suggested as arguments - Command history: scoped to this folder

I wrote dinu[1] a decade ago but integrating with Wayland compositors is a pain (no widely supported "what workspaces are there"), so I gave up a little.

[1]: https://github.com/weltensturm/dinu/tree/dev

(1) Removing the mouse from as many workflows as possible

(2) Switching to a tiling window manager, in my case i3

Everything else has just been various ways of shuffling things around with no benefit to anyone.

I work mostly with remote cloud services or headless servers via VPNs. For the cloud I rely on Firefox over networked X (something that is getting harder to support).

A single-computer desktop is no longer a realistic working environment.

There's no reason a GUI toolkit couldn't be written to enable a lot of this without the developer having to directly implement it. A lot of this could be done just by creating a default interface for manipulating the UI as a sort of DOM thing, and providing default support for synchronization, which is one of the big killers of trying to script a UI, knowing when a task is actually done and you can safely send the next command. (Or maybe someone implements https://news.ycombinator.com/item?id=49482709 , which would also as a side effect improve the ability to synchronize for scripting uses as well.)

We've had so many stabs at this over the years, in Applescript, in expect CAD interfaces, in the ideas behind Powershell, in so many places, but in my opinion what has always killed them is the barrier to entry. Now that's gone. Anyone should be able to say "Take this spreadsheet, search for these rows, extract these columns, send them to Photoshop as a text input here, save the result as a PNG and send it to my AI with this prompt, send the result to my printer and tell my accounting software to complete order #blahblah and send the bill" nowadays, except for the fact the desktop system will buck and fight you every inch of the way because it's just not built for this.

Though what will actually happen is AIs will simply get so good at manipulating desktops in general that they beat any possible project like this to the punch. Even so, even an AI would prefer a genuine, guaranteed programmatic interface to a virtual mouse and keyboard, and be more reliable with one, for all the same reasons we would in their position. And it doesn't have to be a big bang, the AIs can use this when it's available and grease it over for programs that can't do this, and it will increase the reliability of the whole pipeline.

I like point-and-click GUIs, no tiling, no MacOS style dock that wastes screen space, just the Windows UI without Microsoft! That's why I picked Linux.

One area where I haven't seen much improvement is in controls. There haven't been any new controls for ages. In the 90's we got the tab control, tree control and spinner. Has the evolution of controls stagnated over the years?

The part where I immediately tune out is A.I. I don't want an A.I. controlling my desktop let alone changing anything on my filesystem. KDE would do well to completely ignore A.I. integration.

I'm a fan of MacOS stage manager (we exist!), which sort of does this, but admittedly it is under baked (it's lacking on keyboard shortcuts, for instance).

I guess, the only thing it's missing is an AI agent component, but for now I don't know how to integrate one and trust it that it won't leak my personal data, so I prefer not to mess with that stuff.

   > People get angry when they have worked hard to get their desktop environment just as they like it and something changes to disrupt that. "And I get that. As I said before, I don't want to change everything." But the world is changing, "and we need to grow our way gently into some new things."

Sadly I think that I saw that too many time the useless and hated change just because things had to change. Like android theme instead if fixing bugs...

My own Linux desktop experience peaked with Compiz, and I have been on macOS ever since.

The only problem remaining is Chromium not using the PRIMARY selection, so I have to do a weird Ctrl-Shift-C and Shift-V to it but on the way from Chromium, it's 2 Ctrl-C and Shift-V, because Ctrl-Shift-C inside Chromium opens the Developer Tools.

What we need (and to some extent we get in web, i.e. gmail is different based on resolution) is different UIs based on the interface one is using. a single app that can switch between UIs.

I strongly believe the lack of this is why convertibles have remained more of a gimmick than anything else, as in practice you either keep using the app the same way you always did as you switch usages or you use different apps in the the different usage scenarios because they are tailored to that specific usage scenario. Neither are things that really sell the convertible as something with strong usage.

The closest we've gotten is things like DeX on samsung and perhaps what google is rolling out with android.

  > He thought that it would be possible to do the things he was demonstrating with Wayland as it is today.

> The final, particularly strong, objection from the tech community is "don't touch my stuff". People get angry when they have worked hard to get their desktop environment just as they like it and something changes to disrupt that. "And I get that. As I said before, I don't want to change everything." But the world is changing, "and we need to grow our way gently into some new things."

Unproven innovation shouldn't be forced on people who don't want it. It should start by proving itself with people who have an appetite for novelty and opt into experimentation. Winning their interest will be a lower bar anyway, generating better constructive feedback on half-baked ideas, with less risk of backlash. Then, as ideas are improved and vetted, they can work their way into the mainstream.

The fact that they're not describing any such process, and instead announcing that they're coming straight for the "don't touch my stuff" crowd, makes me very wary that they think the hardest part of UI innovation is forcing people to use it against their will until they accept it.

Ah, yes… Famously UX-friendly Google apps and services…

But then again this explains a lot KDE is… yeah.

As a software develop I have numerous web browser windows with tabs, numerous IDE instances with tabs, numerous terminal windows (I avoid tabs but other people love 'em), Slack, Outlook and a few other things. I really want a system-scope panoptic view of all this stuff and a system that has a strong statistical tendency to put the next thing I'm interested in my face and not the opposite tendency which has been the dominant paradigm since GNU emacs and is just as bad in current IDEs.

However, I think it is better to think in terms of open source "desktops" than to think that any UI would be the best for everyone.

Even if the desktop turns out to be done though, UX polish like that drag thing is still a good idea. Like why does no major desktop let you just put icons on your desktop the way classic Windows does?

It really is currently the time and chance for Linux to finally innovate again.

* Alternatives to tree filesystem UNIX introduced (see WinFS, or how Android/iphone manage it)

* Alterantives to WIMP as discussed, specially for large monitors (37" - like 57")

* Every App should provide a REST API to access its functionality remotely (for AI and data exchange. Think OLE/COM in Windows, but good)

* PLAN9 anyone?

https://media.ccc.de/v/kde2026-7-are_we_really_going_to_use_...

As I recall X11 doesn't really support that at all so there was no way to implement that on Linux. Doing it on mouse up seems sensible though. I couldn't find my bug report but I bet it was met with "I like it broken".

If Englebart was right, then the open source desktop is already light-years ahead. It is the only place that provides the option to pick, choose, mix, match, & experiment. That, and the steep-curve GUI needed in one line of work may end up being entirely different from the steep-curve GUI needed in another. The move to "unify" desktop & mobile in the browsers & window managers (free or proprietary) is a glaring example of how one one size does not fit all. I cannot tell you how many people outside of our circle still mourn the loss of scrollbars.

For one, the ability to change how the desktop itself works while it's running, without restarting it... modifying the code on the fly. And if I manage to crash the window manager or some other desktop component, easily just restart it without having to log out or restart all the other programs.

And being able to pretty easily run and manage hundreds of windows. Log in, open one desktop for each project, and just leave it running until the project is done. Maybe reboot for upgrades once every year or two, but otherwise no disruptions.

NO DISRUPTIONS. I don't even have the underlying plumbing installed for notifications and stuff like that. They can try to interrupt me, but they'll find those API calls aren't plugged in to anything.

Freely mixing and matching tiled and floating windows, each of which can be its own tab group with multiple arbitrary windows sharing the same frame. Super handy having free-form placement and grouping of absolutely anything.

No minimized windows. No task bar. No icon tray. No desktop full of icons underneath the windows. The entire screen is one big canvas, to be used however you like. If you need more space, just hit a key to open another desktop.

Manage nearly everything with a keyboard. Mouse usable but not required.

Sloppy focus, of course. (i.e. focus follows mouse, but stays focused if mouse "falls out" of a window into empty space) Not click-to-focus. And definitely no raise-on-click or raise-on-focus.

Mouse keys built into the keyboard, for clicking, scrolling, and moving. Mouse warp too, to teleport the cursor, like having two mouse cursors and a key to swap between them.

A full set of launcher hotkeys which are easily configured and managed by making short shell scripts. Like, F1 to F12 run scripts from ~/bin named like "f1" to "f12", and "shift-f1" and "ctrl-f1" and "shift-alt-f1" and "hyper-shift-ctrl-f1", etc... if a script exists, the key is mapped. Ideally just symlink the named key to a program or script with a more descriptive name, like "shift-f3 -> open-todays-journal-in-vim.sh" or something like that. Easy to see exactly what each key does, with a "ls -l" or similar. (can send a normal f1-f12 event by holding Fn and hitting a number key or the two keys next to the numbers, but I barely ever have a reason to)

Network transparency for everything, of course. It's wild that newer desktops have chosen to remove such a useful feature.

Work at my desk with a notebook to either side, all using a single keyboard+mouse... just slide the cursor off one screen and onto the next. Pick up a notebook and move to the living room. Use its keyboard+mouse to control the notebook plus the television, in much the same way... slide the cursor off one screen and onto the next. Pack up and go to a coffee shop. Control the remote home computers from the local notebook, using their running desktop session. Or run programs natively on several remote computers, with the windows all opened together on one desktop on the notebook.

Automate inputs easily, whenever desired. Record and play macros which work in any program.

Configurations revision-controlled and synced across all my devices, privately, without any data leaking to a corporate cloud.

Organize data into a rich set of nested topic directories or project directories, instead of organizing things by file type into places like "~/Pictures", "~/Documents", etc.

But also, a directory for each day, to hold all the other misc stuff which doesn't fit elsewhere. And a key to easily access it.

Shell scripts can easily know what program I'm using in the GUI, and what directory the focused program is working in, so scripts can take context-sensitive actions.

Automatic private logging of what I do, with easy time tracking and arbitrary queries, using simple plain text log files which are small, easy to grep, and easy to build custom tooling around.

Human-readable plain text everywhere. Plain text files are versatile, powerful, portable, compact, timeless, accessible, and future-proofed.

No churn. No need to retool every few years. Long-lived tools which are mature and robust. Maybe not the flashiest or most fashionable tools, but "bells and whistles" and "useful life" are typically at odds with each other.

A rich vocabulary of small, simple tools which each do one thing well... makes for a powerful, expressive world of deep functionality thanks to the power of language. It empowers the user to do anything they can express. But a small set of huge tools, while initially a bit easier, tends to quickly become limiting and stifling.

I think a lot of the "right answers" for interface design have been figured out for a long time. That is not to say new interfaces are bad... but anything which throws out the old battle-tested solutions in favor of something radically different is going to take a long time to reach anywhere near the same level of usefulness.

They should make more things like that and not worry too much about the average user. The average user will end up doing whatever capital interests dictate they should

It was dismissed as a toy, but I found it very productive.

I use a fluxbox desktop, and don't want, what I consider to be toys, comprising the bling features of gnome and KDE.

I just want a user, text, configurable menu system, with no automatic anything.

To me these calls that "it works don't fix it", just demonstrate how people have almost exclusively used typical M$ and apple desktops, and aren't familiar with the breadth of desktops that are available for a *nix system. (I'm talking about things that don't have anything like a "start bar")

Much can and should be done.

EDIT: I use a 75" 4K TV for my monitor, and have pretty much what he describes in the large monitor part: the applications I'm using in the middle, with data monitors and ancillary applications to the sides. But I also use 8 desktops. One for each general computing activity: browsing, email, document editing, code dev (different projects each on their own desktop), etc.

Another thing that I find amazingly absent in typical computer use: I almost never reboot. My desktop currently is at 460 days of uptime. This isn't an uptime contest, it's the convenience of having a complicated mutil-desktop environment, that I don't have to setup from scratch each day.

Sure they are doing much more, but very little of it makes much difference to the desktop, surely?

> NEPOMUK

Oh, how I hated that thing... At the time it was added to Fedora, the support forums were blowing up with complaints and requests to remove it. I've never seen it do anything useful, but it was always at the top of the top (pun intended), if it was still present in the system. Whatever its use case or design goals were, it just was not a good quality program at all. It's a shame that it might have been an interesting direction, if it tanked almost exclusively due to poor execution.

Finally, on the new directions in the desktop features: some do look interesting, like the Canvas thing. On the other hand, it feels like it might be technologically challenging as the concept itself is too open-ended and doesn't have a small and easy to understand model of operation behind it. Well, time will tell. Maybe it will materialize in some way.

I also think it's unfair to say that nothing conceptually new has happened on desktop for 40 years. Tiling managers are definitely deserving of such a description.

I also think that if we are talking about "specializing" on wide screen, then, maybe even more prescient is the problem of multiple screens. A manager that is aware of multiple screens beyond merely duplicating or gluing them together would be a big improvement. I.e. if screens were assigned roles based on expected functionality / received their own character based on what the screen is assigned to display, perhaps, each having their own cursor, or windows stack that don't overlap with the other screen etc.

I want to get some work done: Just as an example, this work consists of reading some email like "pls review this document, and create a presentation in response". I'll follow up the email with an answer and some clarifying questions. Then I'll read the document, making some notes. I'll read some additional documents, google stuff, look up some numbers, do some calculations, make more notes. Then I'll start drafting the presentation, refining it until ready, reading my notes, firing off another email with a few more questions. Then I'll send over the first version of the presentation.

Now all of those things live in different applications. All of those applications might be local file based or web-based. Some can do both. So I could try putting all the relevant files in a folder, holding all the files I need for this task. But wait, when I save an email as a file there, I cannot properly respond to it anymore. It is just a copy of the original email. Same for all the web-based stuff that even allows local copies. If I use hyperlinks, in the URL-as-a-unique-resource sense that was originally intended, I could link it all together in my notes. But many, if not all, modern web applications do not work that way, I cannot really link anything. And even if, most URLs are not stable. If I google something, I'll find a page I can bookmark or copy the URL of, but that page will change. To save the current state of that URL, I'll have to jump through a lot of hoops to maybe get a PDF printout file or something. And changing any document usually overwrites the previous version, so I'll have to do *-copy17.odt or deal with 20 different broken internal mechanisms of "version tracking". I can check everything into git, but then all the applications will have no clue how to deal with it, no proper diff, nothing.

One thing that I actually want was implemented in the first version of PalmOS as a hack: every application could contain links to every other application's content. You could link from a calendar entry to a contact who you wanted to visit. You could link from a contact to a note, detailing your last talk with each other. You could link the note to the last offer you sent the customer. etc. Of course this was rudimentary, but it was a start, which unfortunately died with later versions of PalmOS where those hacks were no longer possible. So for my original example, I want the original email to be annotated with a link to all the files I've created in response, all the web searches I did, etc.

Another thing is the notion of version control, extended to all desktop and web applications. I want to know what I did, when I did it, why I did it, and what related changes go together. I want to see the same thing for all my colleagues. I don't want any "this file conflicts with what your colleague did, which should I overwrite?". I want proper merges. In each application.

The only thing that even comes close to this nowadays is something like Emacs Org-Mode. If you stay strictly in Emacs.

Or is it just that I didn't try enough stuff and there is a real solution?

Despite this, I still love the open source spirit. It's true freedom becoming more of a privilege for the few these days. I've thought a lot about over the years and i've felt that it has to do with having too many cooks in the pot.

You're just not going to get something cohesive and stable across all the different layers that make up an OS. I call this the Bernie Sanders phenomenon(sorry for non US folks this is just my opinion). I always wondered why we can't get things done in politics here in the US, and it made me realize that we're really optimizing for the lowest common denominator, which isn't great.

But when you have a dictator like situation, the quality of the dictator will dictate the rest of the environment. I think that's sort of how the Apple UX got created. So I don't know if it's even possible to have an open source desktop environment that's cohesive and works across all the layers.

There would just be so much work to be done across Linux as a whole to unify all the different layers and make them more strongly linked with each other to help eliminate the dropping to the terminal. That would certainly improve the desktop experience and make it more cohesive, but it would kill a lot of the spirit of what makes Linux great and competitive in other areas.

Could Linux become ahead of the curve and adopt something that is the next paradigm? I have my doubts. Open source has always been a laggard in this area and at best you get to see experiments but a finished product(thats always one step behind) comes out only after some commercial enterprise has proven it.

Something I find sorely lacking in most modern desktop systems, Linux included, is the performance I expect given the power of the hardware available. Barring that performance increase, better perceived performance through subtle UI changes that elide over waiting moments is nearly as good.

Linux leaves a lot to be desired here. It's easy to bash Windows or Mac, but the performance issues on these systems are often difficult to perceive during normal usage while in Linux it is front and center and harder to understand because Linux is a box of parts.

You could basically look at all the ways that UX has advanced on the Web and almost generate a very long TODO list of things to improve on the desktop. I know there are a lot of people here, especially of the Linux using variety, who revile Web UX, but the things most people complain about (privacy concerns, bloat, document vs app platform) happened specifically because desktop UX stopped innovating 30 years ago.

Some personal peeves, all from having to reimplement these things in projects over the years, which is now many projects because I'm now old, so having to do the same things over and over again is getting annoying:

Multiple Document Interfaces used to have built-in support in GUI toolkits. Pro-oriented editing environments like Visual Studio not-Code and Photoshop gave you the ability to have multiple documents open and operate on then on a single application context. While this is a bespoke implementation in those programs now, that's largely because the UI toolkits didn't keep up with newer features like docking, tabbing, etc. Browsers themselves also had to implement bespoke UI for tabbed documents, again for the same reasons. It's shocking how bad this is in VSCode, where certain kinds of sub-Windows can only be put in certain places, but again, that's because they had to do it from scratch. Now, there is no MDI support in the browser at all, you're left implementing it from scratch, and modern GUI toolkits seem to all just try to ape HTML/CSS (not that I think that's a completely terrible approach, but only because The Desktop Toolkit is Stagnant).

With modern large screens, I find myself at a loss for how to use all the screen real estate effectively. Not that I lack for need, but because I can't seem to get everything I want to see into a comfortable position without sacrificing some other thing. Yet, at the same time, I can't seem to fit much in my own application window. This one is more on me for not having too great of design skills, but I think there are some fundamentally difficult issues to solve here since nobody is going to have a 40” laptop. Fundamentally, the issue is one of being too rigidly reliant on the Application Developer to implement such things as MDI and tool layout. We kind of figured that out with responsive designs break-pointing when going to truly small screens on phones, but I think this could be done more automatically if the GUI toolkit was better.

Smartphones, laptops, and desktops aren't the only 3 workspace sizes. There's also the completely borderless, 3D space of the VR home environment. After experiencing Windows Holographic for the first time and experimenting with using a Hololens as a primary compute device (and then drinking away the massive headache), I found a lot of interesting glimmers of how spatial computing could do a lot for people. I really enjoyed having 2D documents mounted on the wall behind my desk, not needing a screen to take up space on my desk. Having a music player app pinned on a specific spot like a HiFi stereo stack just felt so much more comfortable than wearing headphones, and it was so much easier to turn my body to interact with the stereo rather than sift through my window stack to find the music app. Keeping certain app widgets in certain locations around my house (notes on my refrigerator door, Email away from coding) felt very natural and like it was helping me re-establish balance in my work. But it was all for naught as MS killed Windows Holographic and all the other devices are just pushing virtual 2D screens on which unmodified WIMP interface desktop or mobile apps can run.

Handling the myriad of document types bespoke for every application is extremely bothersome. Having only the file extension for any hint at the content type is extremely unreliable and incomplete (there are thousands of known content types not just image/png, image/jpeg, text/plain, text/markdown, and application/json). Plus, the extension only tells you the container format, the data itself could be in wildly different schemas/encodings, especially when dealing with .json or any audio/video files. Doing deep content inspection is slow and also unreliable because so many JSON-based formats don't reliably implement JSON Schema. This could be solved if we got rid of file extensions and had the full content type string embedded with the file at the File System level. A file's name should be a description of the contained content, not overloaded to store data encoding information.

After writing all of this, it started to dawn on me that these are all the same problem of wanting to composite application together from smaller bits in a unified workspace that I the User control, not dependant on me the Application Developer to provide the support for it. Because, at the application layer, I can't. I can't unify whatever features I'm building with features other app devs have built. We need this to be at the DE level or there isn't a standard to which app devs can work.

Even my complaint about content types fits into this because most of the time I just need to display and play back a file in whatever the one standard way there is to display such a thing. I'd much rather the UI toolkit provided better media players with an OS that went beyond the application window for giving people the ability to composite functionality together. With Adobe Acrobat installed, I as a User should now be able to use PDFs anywhere else I want to view Text or Markdown or Word documents and I as an Application Developer should not have to think about what document formats my users might throw into my application.

The VR home environment makes this issue a lot easier to see, as the Window does not make sense there, but I think this generalizes to 2D, screen-bordered scenarios. Most of the need for better application composition is around not having to rely on every Application Developer to implement everything themselves. Because, when you leave it to App Devs, you get abominations like Snapchat and Instagram.

Sorry but that's the last kind of person I want to have any say about my desktop. If I wanted dumbed down mass market design I'd use a mass market OS. Hopefully KDE resists what this guy suggests.

And of course he proves my concerns right at the end:

> The final idea he discussed was a way of gathering ""privacy-preserving data""

No, fuck off. You have not right to gather any data from my systems.

> when I joined, we weren't evil; we were really trying to do the right thing

Says everyone who worked for big tech ever.

.

Linux software isn't lacking in UX design, it has made different tradeoffs and that's OK and often even a strength:

> The developers wanted to put the ellipsis at the end of the file name, but he thought that would lose too much information, and suggested that the ellipses should be in the middle of the file names.

Both solutions hide the same amount of text and which hides more important text is coincidental. On the other hand hiding the end of the filename is more predictable for the user who can choose to put important information first for longer filenames.

> On most Linux systems, though, if a user is trying to click and drag a file from a window in the background it will cause the window to raise as soon as the user does the "mouse down" action. That complicates trying to click and drag a file from one window to another. That is a fundamental action that means that users can't move data into applications quite as easily on Linux as they can on the Mac.

Raising windows on mouse down lowers latency for that action, which is much more common than the edge case of dragging from a partially covered window to one that would be covered if the original window was raised.

> The point he was really trying to make, though, is that the desktop UX had not really changed in 20 years. There were plenty of new ideas and improvements in the 1980s and 1990s, ""and then it just stabilized, and not much has really changed"".

That's good and expected. When a technology matures then improvements become more and more incremental and less and less things you'd recogize as big change. I don't need or want some mighty designer disrupting my workflow with grand new ideas how things should work.

> Much of the UX for Linux systems was originally copied from Windows and the Mac, ""KDE even says it's for Windows users, that it wants to be similar to Windows for users"".

Much but far from all. He's really underplaying the window management improvements like soft-tiling that e.g. KDE has brought to the table and which were subsequently (badly) copied by Windows and not the other way around.

> Jenson theorized that the reason there are so many desktop environments, window managers, and Wayland compositors for Linux—as well as alternative clipboard managers—is because the desktop isn't quite working right for users.

No, it's because "right" is not a constant across all users.

> He noted that the center of a widescreen monitor is good for working with an application, but it becomes more difficult to work on the sides of the monitor. ""It's good for peripheral vision, but not good for working"".

I don't agree with that premise at all - in fact, having at least two widescreen monitors is the bare minimum for developers around me.

Also all the AI detours are just distracting and worst case betray the real motivation. No, you don't actually HAVE to address AI in every talk dude.

And no, the semantic desktop, just like the semantic web, did not fail for primarily technical reasons but because its a solution in search of a problem.

I mean especially in the age of AI agents, two things are true, first, customizing your desktop, tiling manager, monitoring widgets, shortcut keys, hooking up hand gestures, eye tracking, foot pedals, whatever, to workflows is now so much easier and accessible to completely non-technical users, especially in open source desktop environments.

This is undoubtedly a good thing and many of the responses here are along the lines of 'I like to customize it like this' but I'd bet a lot here also know completely non-technical users who have setup their own weird ass workflows using excel and autohotkey or whatever just to get shit done.

The second thing that is true, is that increasingly we are handing control of apps to AI agents, or even just whole desktops, which is just greaaat (tm). but also incredibly risky since our desktop environments are built on 1970ish era unix multi-user mainframe system design, where one app you install has access to every single other app in the same user space, which is basically root, since you hold everything in one user login anyway. So all it takes is one supply chain attack, one malicious package take over, one zero-day prompt injection against a popular app in a certain segment and then your entire user profile and all your data is exfiltrated.

There are people working on this, Flatpack, Wayland, Fedora. But I think it needs a lot more attention. Android has got this model right for the most part despite the friction it sometimes introduces.

Also I would say this is not just about ai agents thing, but I don't want to install a desktop meme generator program (or pick your thing) and then have it be able to monitor the entire rest of my user profile. This problem existed before AI agents, its just maybe more relevant now.

It is very hard to pin down the problems with Qt because on the one hand you can produce well-working UIs with QML if you are committed to it, see Telegram which has a near-perfect UX and I've never had it crash on me. But I think this is more of a cultural problem: KDE is spread thin, has no real leadership and tries to create a "inoffensive medium" of a desktop that pleases "everyone".

What would be better is a) finally ditching Qt Widgets completely and using QML for everything across all applications, b) moving towards a more functional-reactive approach and getting rid of the OOP mindset inherited from Qt Widgets (which fuses visual and domain data) - hard to achieve with Qt and c) requiring the developers to use some version of Windows and macOS in between, because it happens often with Linux users that they get "blind" to their own issues habitually, they need to experience what 90% of the world uses, so then they can take the good ideas to KDE. But if you use Linux 100% of the time, obviously it'll be "the best" because you're so used to its jank.

Also, develop a target audience. He hates on Omarchy in the video, but at least Omarchy has a target audience: the agentic-first, keyboard-first hypebro libertarian SaaS web developer. Okay, maybe a niche audience but at least that's something. KDEs target audience is... "everyone". Which then results in a "mid" desktop which just has to be worshipped by the fact that "it's open-source". And now, apparently the target has switched to "corporate users / governments". I'll say this is a bad idea because that's like an abusive relationship, you have constant bureaucracy, have to agree with their politics and views, have tons of red tape and low IT literacy. But at least it's "a" target audience, better than pleasing "everyone".

I will believe KDE cares about UX once they finally fix the clock to have the same font size for date and time, like Windows does it - first rule you learn in web design is to not use too many font sizes and KDE immediately breaks a very basic UX rule and has inconsistent font sizes everywhere. Then afterwards, they need to learn about stem widths and why using "1px borders" and thin fonts is not exactly the best thing for readability or low-resolution monitors. There's just so much wrong with KDE and Qt, architecturally and visually, that the "bad UX" problem is just a downstream result and I don't think a glorified Stage View will fix this.

Some backdrop, a thesis: tech used to be exciting because there was apparent motion, things changing. The dread hadn't set in, and I think that dread set in because tech shifted from close intimiate and touchable technologies we could touch, to far off systems running in some cloud data center/keep. Change was fun when we got to be on for the ride and feel some ownership but change happening to us was annoying.

So lately, it's hard for anyone to know what their preferences really are. We aren't trying a ton of human empowering things. The organizational systems Scott talks about here? We see some absolutely ferverously dedicated people enjoying Niri, enjoying new infinite space tiling systems. That's a rare example though! A couple people stumble their way into it. There's not that WinCustomize era where it's apparent people are active and busy and rebuilding, remixing their world on and on. People aren't in a receiving trying mode, because in part there's not a ton to try, and because there's no scene, people aren't kicking out new things either. The social poverty of the area & lack of things to look forward to mean people aren't looking, and people trying stuff are lucky to get traction, even when it's good.

This admits some of the "don't touch my stuff." Because we haven't been seeing as much upside to change. But also: it's pathetic! These peole have had their spirits crushed and have no peers out there who are having fun, so they can just wallow in their grumpiness. And we need to kind of ignore these users, because they don't know: they think they want not even faster horses but merely horses that stop breaking down or which start only turning left unless you pay premium. Let these naysayers and grumps alone. But more than anything: show the people you can reach good stuff! Activate interests! Try to restore a sense of motion & exciting change! Create more powerful, richer, more beautiful systems!

Agents help though. Change sucks when it gets in the way. The downsides though are lower than ever, if you have systems flexible enough to let agents work them. If something changes in a way you don't like, an agent may well be able to make quick work of it! Tell it, and it'll go fix it.

Last: the granularity of build it yourself systems is not great. Downloading Sway, a desktop shell atop it,then a launcher, then a host of other small utilities to cobble together is a lot of decision making to do, and most of these options for these roles have lots of competitors with little interoperability. The tools that makeup the desktop stand alone, small pieces, and it's up to you to pick each one and loosely couple it, with it's bespoke means of doing so. These patterns of assembly suck. There's significant money heading towards a new omakase system, and I don't think it's necessarily the authoritarianism/fascism per se, the desperation for authority to make sense of the world, but given how scattered the pieces are, I have some sympathy for why they want someone to say they've built the beautiful well hewn omakase thing. And that your agent can customize it.

One of my favorite examples for a system that does compose nicely is astronvim on neovim. It takes some well known very great core plugins for nvim, and builds a little zellij like mini-framework to nvim's tmux atop that: a visual leader key, with menu system builtin. It creates a framework for more to plug into. And then the community has lots and lots of plugins or packs of plugins that it takes from upstream plugins everywhere, and it packages them for astronvim. Hundreds if not thousands of plugins. Most require not that much extra to hook in nicely in to the framework, to make them more apparent, visual, seen in the broader system. The system composes capabilities into itself nicely, integrates. Where-as when you get a regular nvim plugin, it usually can assume either nothing or way too much about what kind of nvim it runs on. It has to define it's own world. I think astronvim is an incredible model for making common layers for assembly, and it's packs show something inbetween a single plugin and an app: it's a unit of software that aggregates a couple other modules, yet is shy of being a full app. That kind of composability of experiences is unique and special: not having to assemble every piece ourselves, and yet not having an entire massive system dropped on us. Figuring out how to deliver better units of capabilities, composable subsystems, is really missing on the desktop and is much needed.

[Agent: Fetch cat pictures from the internet] >GetFromFolder> [Agent: Filter for Calicos] >> [Agent: in Gimp paint Cat-Ears on Cats ] >> [Agent: Generated Videos] >> [Agent: Reupload to Youtube]

If you can make a "Explorer" with zero code and which allows to store and share building blocks and pipes, congrats.

I'm stating that on the basis of having Codex mutate my WM while using it (just restarting it without restarting my session) to do things like adding two layer desktops, and snapshotting desktop state, resuming with the applications I want.

There's nothing special about any of that, but what is a bit special is describing a change in desktop behaviour I want, have it churn for a bit and for my live desktop to seamlessly change.

Being able to do that makes it meaningless to lock users into a pre-defined desktop model any more.