• 192 Posts
  • 141 Comments
Joined 2 years ago
cake
Cake day: June 14th, 2023

help-circle

  • On MacOS and some desktop environments like Unity and optionally in Plasma, there’s a UX design pattern called the “Global Menu”. At the top of the screen, as part of the desktop’s shell, there’s buttons labelled File, Edit, View, etc for you to interact with.

    Firefox is seemingly (I haven’t tested it myself, not using Plasma) enabled this functionality under Linux. Previously it required a patch to work. But this functionality has always existed on the MacOS version.






  • Ah I had the same issue. JavaFX still uses X11. By default VSCode only lets X11 be used if Wayland is not available (this is the X11 fallback permission). Disabling X11 fallback will let VSCode use Wayland and let JavaFX use X11. I might make an issue for this on the flatpak’s GitHub asking for this change.

    Honestly, the truth is that setting up containers for development will always be a hassle. My low tech way is just to make a distrobox container with its own home folder, install an IDE in it, and install packages. The more proper way to do it would create your own containerfile to build your container for developing.

    VSCode also has its DevContainers extension but that doesn’t work in VSCodium and does some weird things.


  • Flatpak’s usefulness for programming depends on the IDE and language. IDEs like VSCode largely suck because they are not designed to work in flatpak. But some languages still do work well in them, such as Rust, since Flathub provides the Rust SDK and dependency management is done with cargo. But it sucks for C++, where you typically install dependencies using your system package manager.

    IDEs like Gnome Builder are pretty good. It’s designed to work within the flatpak sandbox. Even when running as a flatpak, you can choose to build things using containers or your host system. And of course also build using the Freedesktop runtimes.

    I recently setup JavaFX with the flatpak version of VSCodium and have it working pretty well. You first need to install the Java SDK from Flathub, set an env variable to tell VSCode to load the SDK. The more annoying part was JavaFX since it’s not part of the JDK anymore. I just downloaded the JavaFX tar, extracted to a directory called JavaFX, and set $JAVAFX_HOME to point to it. Since VSCode has host filesystem access, it can access it. Few more steps than traditional Linux, sure, but still easier than MacOS and Windows.

    Not sure about your database situation though.




  • Don’t believe so, best that’s currently available is skimming through the video to look at the slides.

    Here’s my short summary of the presentation, I tried to denote what’s being worked on (open PR), what’s kinda being done (WIP), and things stuff they’d like to be done in the future (wishlist). May be somewhat wrong.

    • Flatpak is stagnant
    • Red Hat is working on a better way to preinstall flatpak apps (open PR)
    • Flatpak should is slowly moving towards OCI and away from ostree (more tooling available, don’t need to maintain their own tools)
    • Better permission handling that is more backwards compatible (open PR)
    • Should directly use Pipewire instead of Pulseaudio (WIP)
    • Allow user namespaces in flatpak sandbox (WIP)
    • Move dbus proxying into dbus brokers (wishlist)
    • Improve network sandboxing (wishlist)
    • Improve drivers handling, currently drivers need to be built for each runtime, could cause issues if using EOL app on new hardware (wishlist)
    • Work on portals directly improves flatpak



















  • I looked into this a bit more. It turns out that Metadata Cleaner was marked end of life by the owner because it’s no longer being maintained. This is different from the more common scenario where an app is using an end of life runtime. I guess Discover decides to remove apps that explicitly marked as end of life.

    Still, it’s a poor UX to not give the user the choice. You may be able to work around the issue by pinning Metadata Cleaner, either using the CLI or Warehouse, an app to graphically manage flatpaks.







  • Unfortunately not. There’s been a number of things on Nvdia’s side that slowed down Wayland adoption.

    They didn’t always support Xwayland hardware acceleration.

    Nvidia pushed for a technology called EGLStreams while everyone else agreed on GBM. So the desktop stack had to support both. Nvidia eventually relented and started supporting GBM.

    Nvidia didn’t support VRR or night light for a while.

    Nvidia didn’t support necessary stuff for Gamescope to function properly.

    And overall Nvidia on Wayland was just buggy. I remember that many games failed to launch or had weird performance issues. But those issues just went away when I got an AMD card.

    But things are in a much better state today. Though I did recently test a 20 series card on Fedora 41 and it was a terrible experience on the proprietary drivers. But when speaking with orhers, they didn’t share my issues.


  • One opinion that Wayland has is that the client is responsible for decorating its window. It draws its own title bar, shadow around the window, and the cursor.

    Though not everybody was happy with this. A few protocols were created that lets clients tell the compositor to draw decorations around the window and the cursor.

    But still, every app needs to support those client side decorations and cursors because not all compositors support those protocols. Gnome notably doesn’t, they like client side decorations.


  • Before Wayland, there was X Window System, created in 1984. X Window System was designed in a time where you had one good computer connected to multiple displays used by different people. X went through many versions but version 11 (X11) stayed around for a long time.

    But the architecture just isn’t good. It wasn’t designed for modern needs. MacOS used to use X, but replaced it to fit modern needs. Windows didn’t use X, but they too updated Windows to fit modern needs. But Linux and other OSs stuck with X for a lot longer, hacking it to make it work. Honestly, it’s amazing how well it does work.

    But isn’t not great. It wasn’t designed with security in mind, it doesn’t do multi-monitor well. Behind the scenes, it considers everything to be one giant display; issues arise when it comes to mixed-dpi displays and when monitor refresh rates don’t match. It’s also just a bloated, old code base that people don’t want to work on. Fixing X would not only be difficult, but would break compatibility.

    So people got working on a modern replacement for X aiming to avoid its issues. Wayland is leaner, more opinionated, and designed for how modern hardware operates. Wayland itself is just a protocol (like X11), and there’s many different implementations of that protocol: Mutter, Kwin, wlroots, smithay, Mir, Weston, etc. Meanwhile X11 pretty much only had one relevant implementation, Xorg. Wayland’s diversity has its pros and cons. Pros include (1) you can create your implementation in any programming language you want rather than being stuck to just one, (2) an implementation can fill just the needs on the person making it rather than trying to generalize it for everyone. But cons include the fact that this fragmentation leads to scenarios where one implementation supports something that others don’t and implementation-specific bugs.

    Wayland’s opinionated design is also draws criticisms. It gives a lot of control to the compositors rather than windows, which is how Xorg, MacOS, and Windows work. Nvidia’s wayland adoption was also slow and terrible. It took many years to get it into the only decent shape it’s in now.