4,281 karma · joined July 3, 2023
https://www.wells.dev/
It's often said that macOS/iOS supporting Vulkan would help and while I think that's true to an extent, native Vulkan support is still rare enough that it's not going to change all that much in terms of ease of porting. It might improve things on the front of running games through WINE (DirectX → Vulkan translation), but unless developers produce ARM builds of their games there's always going to be the overhead of being run through an x86 translator, which varies depending on how CPU heavy the game is.
Yes, this is difficult to avoid for various reasons, perhaps the most pertinent being that all the safest places to launch things from are along coastlines where it's easy to divert wayward rockets into the ocean and away from populated areas. Coastlines have plenty of water and thus plenty of wildlife. Launching from e.g. an inland desert is much more risky and the environmental impact isn't necessarily all that much better to boot.
In the case of Quest stuff, PC link users being treated somewhat as second class (no direct DisplayPort input) and the lock-in of the crappy Quest desktop software doesn't help matters.
I agree that VR will always be a niche, but I would also say that there's a good chance of the niche growing with the introduction of a well-built, affordable, well rounded headset that's built on the SteamVR ecosystem.
In short though, frameworks like SwiftUI tend to be designed around a very narrow set of use cases and if yours deviates from those in any way you're in for a bad time, and depending on how great the deviation is will likely land you with falling back to older imperative frameworks for their more customizable/hackable widgets in places (if that's an option) or dropping the declarative framework altogether.
This exact scenario has played out for many trying to adopt SwiftUI. For even moderately complex projects it’s common to get 90% of the way there fairly easily, only for that last 10% to be a struggle/slog as a result of its inflexibility. AppKit/UIKit may not be trendy or sexy and might take longer to get new projects spun up with, but it’s much more rare to hit that brick wall with them; you’ll probably be able to accomplish what you need with little or no pain.
I’ve seen shades of this in Jetpack Compose too, which makes me think that these sorts of problems are just inherent to the type of UI framework.
Bugs aside, it feels like touches more “directly” control iOS whereas with Android it’s like interactions are all passing through an additional layer, leading to an impression of disconnectedness. It’s not entirely unlike the phenomenon that used to be observable on some Linux desktops a decade+ ago when computers were weaker and you could “feel” the layering of X11, GTK, your compositor, DE, etc all kind of slip-sliding and not acting fully in concert, where Windows and OS X usually didn’t give this impression.
So for example, a 20”-24” screen should be 4K so it can run at 1920x1080 @ 2x. Similarly for 27”, you want 5K which is 2560x1440 @ 2x.
This is a really good post describing how it all works:
It seems like a near impossibility for other manufacturers to not phone some of those things in. There’s always a catch.
It’s not a “it’s not iOS” thing, either. There are certain desktop Linux setups for example that don’t bother me nearly as much. It’s just Android that feels “wrong”.
If only the entire front end of Android were interchangeable like Linux DEs are.
So realistically, judiciousness is required to keep it all glued together, and some usage patterns just won’t be accommodated.
For example, Apple doesn’t seem to be bending over backwards to make former Windows users happy, because the way that desktop works is just too different from what they’ve envisioned and what their long time users are used to. If they add a series of toggles to support Windows usage patterns, that’s a sudden 2x multiplier on the behaviors and UI that needs to be tested.
That said, I don’t necessarily agree with all of Apple’s decisions (I’ve never liked the linear representation of virtual desktops that in place since 10.7 Lion that well and preferred 10.6’s Snow Leopard’s 2D grid, for example), but the lines have to be drawn somewhere.
It’s just that they expect these users to have fairly specific usage patterns and design around those. The further one’s personal patterns deviate from that expectation, the higher the level of friction encountered.
All the current options, even those geared towards Linux specifically, make significant tradeoffs in one or more of these areas, and I think this significantly curbs Linux adoption.
My preference is that email and calendar are two entirely separate apps, because I have my calendar open for about half of the emails I compose, and the remainder of my calendar usage has nothing to do with email at all. This is one of the reasons I've stuck with Apple Mail + Calendar through the years.
The problem with using almost any existing DE as a base is that Linux DEs are all inclined toward non-mac UI paradigms (most being Windows-like and a couple iPad-like), which means required changes will be numerous and deep. So much so that the benefit of not starting from scratch is dubious.
I’m not sure how much productive it’d be in the long run, at least if faithfully replicating macOS is the goal. PopOS is bailing on GNOME (what it had been using) in favor of a bespoke DE because modifying GNOME had become too much of a pain, even for their relatively modest changes. Pantheon (elementary’s DE) closely resembles GNOME for likely similar reasons.
Not that any of the other DEs would serve as better bases, unfortunately. No matter what making a Mac-style DE is going to be a steep uphill climb.
I will caveat this by saying I haven’t worked with GTK and don’t know how well-tooled it is in this regard. If GTK doesn’t offer any/many parameterized values, then that’s on GTK, not app devs. They’re pretty well supported in macOS/AppKit, iOS/UIKit, and Android/Compose though and should be a cornerstone of any modern UI framework.
I love the form factor, feel, weight, screen, etc… it’s really just the CPU that is ill-fit for the machine. I wish I could swap it out for a low-voltage Ryzen or Snapdragon, which would probably add 4-6 hours of life on the same battery.
This also doesn’t seem to be fixed on the newer Nano’s, which last I knew for some incomprehensible reason make use of higher power Intel Core models instead of the low voltage U-class CPUs that suit it better.
I could totally see using something like Debian stable in a pure Linux environment with no newly-supported hardware being added, though.
I suspect that this is because the average Mac window/view nib file is a great deal less complex than its counterpart view nib on iOS and still manageable to edit in Interface Builder, and so a lot of Mac devs still use nibs.
I've toyed with code-only Mac AppKit stuff but generally have found that it's not quite as clean as code only iOS UIKit. For example if I recall correctly, there's no initializer for NSWindow that sets all of the flags that make it behave like a normal window because it's assumed that you'll be using nibs. It's not difficult to write an extension to NSWindow to fix this, but it has to be done for reasonable productivity, and these papercuts are strewn throughout AppKit. In contrast, most UIKit controls can be initialized with few or no arguments and still behave as expected.
Considering these things I believe such a group would be best served by starting their own DE project and likely writing their own UI framework with first-class C bindings, because while Qt doesn't break things as often as GTK does it's restrictive in the languages it can be used with.