Keith Packard

Current Xorg has Glamor, using OpenGL to accelerate the 2D ops of X11. There is also Zink, OpenGL-over-Vulkan for the rare case of Vulkan without native OpenGL. OTOH, there are people willing to add support for old hardware that probably can't run Vulkan, or even OpenGL, and sometimes they manage to upstream that code. With your "bsder" nick, the following example seems relevant. https://blog.netbsd.org/tnf/entry/x_org_on_netbsd_the [search "PowerPC"] Some old X11 coders still work on it, or make suggestions to improve it. https://lists.x.org/archives/xorg/2024-April/061644.html https://keithp.com/x-ideas/ But such initiatives lack the "new shiny bling" factor, which seems to be a must nowadays to be a "success". It's the curse of "mostly done, mostly maintenance" projects in a world where breaking ground looks better in a CV than polishing and oiling the machinery others crafted.

The issue without "Direct Mode" is latency, as your link says. You need to bypass both the browser compositor and the system compositor. On Linux, most compositors will implement something like Direct Mode (compositor bypass) when you go fullscreen, but it's a bit hit and miss with multimonitor setups. It might fly as a stopgap, though. Here's the tracking bug for WebVR on Linux, if you want to follow progress: https://bugzilla.mozilla.org/show_bug.cgi?id=1310655 Something more directly analogous to "Direct Mode" on Windows are DRM leases, which give direct control over the scanout, rather than simply bypassing the compositor. This isn't possible on Linux at all yet, but Valve is working on it: https://keithp.com/blogs/DRM-lease/

Yes. Sometimes when I'm doing research into recent history of why certain technical decisions were made, and the arguments for or against, I find archive.org invaluable for piecing a line of thought back then. Recently, this was to look up what the debate between React's Functional components vs Signals was. Also, it's helpful to get perspective on the attitudes for or against a new technology in recent history. I remembered there were people that said "If you aren't writing a kernel, you don't have their problems, so you don't need git." Turns out that's not true. Now that git is everywhere, it's harder to remember whether or even if there was pushback against it. This was written about the insights from using git that he needed to highlight to people back then. https://keithp.com/blog/Repository_Formats_Matter/ I often reference it, and if it wasn't still up, I'd have only web archive to rely on. So for me, lots of stuff I look at online (mainly blog posts) are worth saving. Sometimes, if the discussion is on a twitter thread, that too. Which makes me fear for the day Microsoft decides to do Github in, and we'd lose all the issues and comments.

X has had its OpenGL extension available since 1992. Your argument is like saying "Windows 1.0 came out before Direct X even existed, so of course you can't play modern games on Windows 10". As new things came out, they added support for it. Compositors are an optional component. I have never run one myself since they don't add anything of value. So any time someone says "the X server only talks to the compositor" I'm like "lol what compositor". But even if you have one, it is still wrong. You have to understand that GUI applications are a LOT more than just low-level rendering. So even if you didn't need it for that, there's so much more going on that the server still plays its role in like coordinating copy/paste, drag+drop, hotkeys, notifications, etc., etc., etc. And it isn't true that everything goes through the middle man. A graphics-heavy X application actually tends to work very similarly to a Wayland application (not coincidentally - as people love to point out, a bunch of the Wayland devs worked on the gpu rendering parts of X before): you get a direct render context, write to a buffer, then inform it to draw it. See more https://keithp.com/blogs/dri3_extension/ Mixed DPI is fully supported by the system, but may be buggy in applications. See here http://wok.oblomov.eu/tecnologia/mixed-dpi-x11/ you can get information and handle it client side for maximum quality, or do auto-scaling for easy support bridges. KDE and Qt manage to do it. So much for "unfixable".

> Mercurial feels like it should be the winner. The commands are more uniform and predictable. Keith Packard's "Repository Formats Matter" post nicely captures how meaningless it is to focus on this sort of thing in the long term: https://keithp.com/blogs/Repository_Formats_Matter/ I.e. yes Git has some UI issues, but those are fixable, whereas e.g. Subversion's UI was way better than Git in the early days, but its repository format limitations inherently weren't fixable. > Mercurial has a concept of commit stages to make history rewriting safer. Yeah that's a really neat feature. For what it's worth some people at Google seem to be working on trying to get an equivalent feature into Git. > For example, what Facebook did[...] Much of what drove Facebook to Mercurial has since been addressed, e.g. "status" times being slow due to lack of inotify-like integration. That's now a feature of core git. Some of the rest is being worked on and actively upstreamed, e.g. from the GVFS effort: https://vfsforgit.org

As a related fun example that I use at work all the time, take a look at newlib sometime! https://sourceware.org/newlib/ And related to that again is https://keithp.com/picolibc/

Some of the author's blog posts may answer that: https://keithp.com/blogs/embedded-arm-libc/ https://keithp.com/blogs/picolibc/ https://keithp.com/blogs/tags/picolibc/ IIRC they do a lot of stuff with amateur rocketry, so it might related to that.

More on Keith Packard's website: https://keithp.com/picolibc/

FYI.. there's also SNEK https://keithp.com/snek/snek.html which claims to have an even smaller footprint than MicroPython for Arduino Duemilanove compatible hardware. A recent talk at North Bay Python https://www.youtube.com/watch?v=llghdGHtxVQ

Interestingly, the old maintainer (Keith Packard) has a fairly recent (2018) list of improvement ideas for Xorg: https://keithp.com/x-ideas/

Somewhat relatedly, there exists a Python-like language for when you only have a few kb of memory, and can’t even run MicroPython. It’s called “Snek”: https://keithp.com/snek/

For reference, there's also autorandr [1] and x-on-resize [2]. [1] https://github.com/wertarbyte/autorandr [2] http://keithp.com/blogs/x-on-resize/

Interesting approach... It reminds me a bit of Glamor, which is 2D X Windows primitives on top of OpenGL. http://keithp.com/blogs/glamor-hacking/ http://mirror.linux.org.au/linux.conf.au/2014/Wednesday/52-Building_2D…

Exactly! Make the format simple and obvious enough to be applicable for a wide range of purposes. Because humility. http://keithp.com/blogs/Repository_Formats_Matter/ On-the-wire formats matter, on-disk formats matter.

In the case of Xorg, if they had warnings enabled, it was one warning among pages and pages of them. Recently though, they cleaned it up, 1.16 and onward should compile without warnings[0]. [0] http://keithp.com/blogs/xserver-warnings/

with the X bug, building X has always triggered tons of warnings, it's easy to see why they're overlooked http://keithp.com/blogs/xserver-warnings/

> and the whole repository is just a single file http://keithp.com/blogs/Repository_Formats_Matter/

> It is issue with X11. If you have Wordperfect binary from 1999, it still has to work; it does not matter that RandR provides information, old clients will not ask for it and without it, they will be broken. This is why i wrote "so that compositing window managers can do it themselves for applications that do not support it, which is also why this needs to go through the window manager". You do not need X11 support for that, functionality that exist can be used right now to do it - assuming the applications and WMs cooperate to specify the necessary attributes and events, of course. > That's why Xwayland does upscaling by itself. You can also do this with a compositor for applications that do not support scaling themselves (which would be the default state - again this isn't any different than the 'supports close event' flag that already exists for decades now). Without a compositor you're out of luck (for the most part)... ...However! Keith Packard worked on server-side scaling some time ago [0] (not sure if it was merged with mainline) which would allow this to be done even without a compositor (well, kinda, technically the server does the compositing just for the scaled windows). So even without a regular desktop compositor this should still be implementable, assuming that functionality was (or will be) merged in mainline Xorg. But note that this is only for the case where one wants to run applications that do not support scaling and have hidpi scaling and also not…

I wasn't a real fan of the 5.3 change, but it was better than some of the alternatives that people were proposing. At the end of the day, the problem is that userspace just shouldn't be trying to get randomness during early boot. But if they do, and we make the kernel more efficient things can break, and Linus believes that if there is a user-visible regression we Have to Fix it, even if it the root cause is broken user space. In this particular case, what triggered this was an optimization in ext4 in how we did directory readahead, which reduced the number of I/O's done during the boot sequence. Some user space program in early boot tried to call getrandom(2), and it blocked because with a smaller number of I/O's, for some hardware platforms, it would stop the boot sequence in its tracks, and this then resulted interrupt events, leading to no further activity, leading to an indefinite hang. So what do we do? We could revert the ext4 optimization, but what it did was draw attention to the fact that in the absence of a hardware random number generator which everyone trusted, what we had in terms of CRNG initialization was fragile. Now the blog posting is inaccurate here as well, it is not the application which needs to make an interpretative dance of some kind. We actually are doing it in the kernel, and there is at least some hope that on an x86, making some assumptions about how the caches and clocks work, it probably is secure. I am actually worried that it…

> What do you mean by "pixel perfect frames"? Wayland enthusiasts usually use "pixel-perfect frames" to mean lack of tearing -- what happens when the framebuffer is changed in the middle of the "electron beam's" scan down the display and you get half of one image and half of another. Eliminating tearing generally means forcing vsync, which means your framerate is capped at 60fps, and a few milliseconds of input latency are introduced -- meaning there's a bit of a tradeoff between the fastest desktop and the smoothest. (This is true regardless of display stack, whether Windows, Quartz, X or Wayland). Xorg drivers can often run in a "tear-free" mode, but Wayland blah blah modern architecture blah blah designed from the ground up blah blah. Plus, Nobody Ever Uses the X protocol anymore. (Basically, you don't have a choice -- Wayland compositors are required to force vsync and operate in tear-free mode.) Security is, largely, a non-issue unless you run untrusted binaries all the time and/or open ports on your X server to random places that can then run random programs on your display. However, for the paranoid (and a little healthy paranoia is a good thing), it would be more involved but still not a whole lot of work[0] to modify the X server architecture to support a more Wayland-like security model by default, while still allowing trusted apps to do things like take screenshots and respond to global hotkeys. The advantages of Wayland thus boil down to "it's what the…

Well, I am sorry to have to disagree on this. This is no rocket science, and the software support isn't that different from any standard monitor/gamepad combo. That's for the architecture, at least. Of course, latency requirements are higher. But the differences stops here. Face it, today's VR headsets simply are monitors that you wear on your face (Head Mounted Displays). Anyone thinking otherwise is simply lying to himself to make it sound more complicated than it is. Those include a few input peripherals as well, none of them which is particularly complex (valve's lighthouse system is probably as complex as it gets). And lastly, none of these points should require a certificate. Every computation can be done locally, without the need of an internet connection. To be a bit more specific, let's break down the arguments (I have nothing against you, I am just interested in those): > Monitors work without low-level drivers because their maturity (and lack of innovation) allows the hard stuff to be embedded in the operating system. VR is not at that state; it is emergent, and the capability stacks require additional integration into the OS. Vendors frequently add unique features, and will continue to do so for some time, making standardization difficult. This is true... Somewhat. For now, the only integration that has been done in the Linux kernel is DRM (direct rendering manager) leasing [1], which allows an application to borrow full control of the peripheral, to bypass…