HNHacker News
TopNewBestAskShowJobs

crazyloglad

208 karma · joined May 28, 2016

https://www.github.com/letoram https://www.arcan-fe.com
submissionscomments
crazyloglad··on Arcan versus Xorg – Approaching Feature Parity
You have ~three working and the 'defunct' AWB one.

Durden : http://durden.arcan-fe.com is tiling, stacking, tabbed, and a few others rolled into one.

Prio : https://arcan-fe.com/2017/04/17/one-night-in-rio-vacation-ph... - much more simple one that builds on rio from plan9.

Safespaces : https://arcan-fe.com/2018/03/29/safespaces-an-open-source-vr... - 3D/VR.

crazyloglad··on Arcan versus Xorg – Approaching Feature Parity
The closest you'll get is the the "Clients and Privileges" section, and I much prefer to spend time on "what is" and "what will it become" than comparisons.

Part of the problem is that Xorg is much more well defined in that most can grok "what it is" so there is a point of reference to base an explanation from without 'too much' confusion, there's stuff to work on that isn't IRC logs or mailing list posts which is seriously 90% of Wayland right there.

Wayland is not a "protocol" in the traditional RFC/Jon Postel sense. Heck, even the spec PDF itself referred to itself as a Display Server. There's single X extensions with far more coherent descriptions than all of the Wayland Ecosystem. It's full of overloaded terms and technical WTFs!?. If anything, its the worst parts of Micosoft COM resurrected. An asynchronous Object Oriented IDL. Run for the hills.

Some say it'll fix security issues, it'll fix performance issues, it'll fix world peace -- with barely anyone answering or questioning "how", "why" or "why can't X?". When you counter-argue its feature anaemia it is "oh it's just a protocol, the compositor fixes that" and when you question the feature bulimia it is "oh that's compositor extensions, not the protocol".

Neither position is substantiated by its technical underpinnings, the protocol parts itself, nor the documentation, nor any of the the 'project goals'.

crazyloglad··on Arcan versus Xorg – Approaching Feature Parity
It's up to the WM. In Durden, that's how the default works. Advanced management is if you are working with different security domains etc. and need to protect against other clients polluting the clipboard (classic bitcoin address replace attack for instance). Point being that clipboard behavior is WM controlled, not display-server+manager.

http://durden.arcan-fe.com/clipboard

crazyloglad··on Learning from Terminals to Design the Future of User Interfaces
lone dev here, and thanks for noticing - so this is where the traffic came from :-)

The lack of attention (and releases, not representative of the half a million lines of C code and about 100k of Lua it entail) is mostly by design - to a large extent, I prefer obscurity to the point that productivity dips and lethargy sets in around release bursts, it opens up old mental war wounds from academia (also - getting a ph.d wasn't worth it).

The posts etc. so far is much in the terms of documentation, not dissemination or politics. Coming soon: "Arcan vs. Xorg - far beyond feature parity" and "The Divergent Desktop"; that will show how these things fit together. The latter expands a lot on some of the ideas in this article.

crazyloglad··on Revisiting the Arcan Project
Author here - do write it up as a blog post, the discussion should be had and a bit more systematically if you don't mind me saying so, and I have quite a lot of things more to chime in with.

Another relevant point for thought that was provided to me as a response to the original article is the design and thoughts behind https://www.eblong.com/zarf/glk - in hindsight it is more than reasonable that the interactive-fiction crowd had been working in the problem space but not attempting to generalize it.

Vis a vis animations, those can still serve a certain point of they are set up for cognition rather than mere aesthetics. A simple example is switching workspaces. Some of the people I worked with refrained from having tag-sets, or tiling with workspace switching and kept a surprising amount of windows around yet knowing about compartmentalising into workspaces. The argument was a problem with finding 'where all the windows went' on a switch, and that feeling, anecdotally, went away when the workspace switching animation indicated a direction, left-to-right or right-to-left depending on if the workspace index went up or down. That is the mental grouping was not in 'specific windows -> workspace number or identifier' but a spatial place, even if not visible.

While I agree between the gui/tui chasm (and often try to use text-dominant or similar phrasing - though in my head there is no real distinction between graphical and text - considering rendering emoji from a font is equivalent or darn well close to blitting tiles from a tilemap), I consider it more of a gammut where you sortof have to draw a line in the sand. The glyph+attributes in cell addressing model is much less complex than 'per pixel' even when accounting for BiDi/shaping/ligatures. Just don't mix the two which is the norm now, drawing a popup with text characters when it could've been... a friggin popup is a tragedy, and not even a good one.

That said, and this touches upon the bigger idea partly hidden behind the many lines - there is a need for what could've been the 'gestalt' of the mobile "app" idea had it not drifted towards such an opportunistic, exploitative and dark-pattern filled anti-user clusterfuck, and that is the notion of a 'one thing, and well' graphical applications. I think we need both, one biased towards the graphical, one towards the textual and that they can come from the same process, just that some kind of system enforced barriers are in place so the meta-ui (window manager) doesn't degenerate into a hierarchy of nested WMs fighting to block one another's view of the system (browser to window manager to tmux to terminal to shell to virtual terminals) sortof all fight to be the same underspecified 'thing'.

I document more than I disseminate, and the article belongs more in the former category, but for what I'm sortof feeling are concerns you'd enjoy in the context of the TUI discussion are two coming articles (monitor the rss, I rarely touch the browser) "rethinking desktop configuration: my UI is a filesystem" and "leveraging the display server API to bootstrap better debugging" (titles being subject to change).

crazyloglad··on Is there a way to use 2 “mice” on a pc?
there are a few problems that make this idea nasty:

1. input focus / window selection - lots of code relies on the idea that the currently selected window is a singleton, not 1..n_cursors. Adding support for multiple cursors breaks this assumption and code that looks something like active_window().do_something() would have to be biased against the selection tied to one cursor, breaking their independence. You'd ideally want a 1:1 match between keyboards and cursor input devices for this to be workable.

2. accelerated drawing - a very common (if not universal) display server trick is to separate mouse cursor rendering, own content (like window decorations) and accelerated content (like hardware video decoding and color keying) into different output planes with varying drawing restrictions. They update asynchronously in order to reduce memory bandwidth requirements and hide latency/jitter. The number of available such planes are typically low (1,2,4) and dynamic. Adding another mouse cursor breaks the simple '1 output plane @(last sample.xy) cursor.w*cursor.h' and forces either multiple planes to be consumed or the allocated plane size to be primary plane resolution size and updated every frame, which can impact other connected monitors and so on.

3. absolute vs. relative mouse samples / warping - this varies more between windowing systems but some applications deals with a mouse in terms of display- absolute, surface- absolute or device relative samples. At the same time, different mouse devices (touchpad, "normal" mouse, tablets, ...) provides samples in different types (device-relative, device-absolute) and someone needs to do the translation. This matters in situations like FPS games.

4. nested - it is not uncommon for applications to "hide" the global mouse cursor and then maintain their own inside the context of its windows. Games in particular like to do this, but also VMs and similar oddballs. Someone needs to do the translation and it typically becomes dx,dy = last_mp - current_xy then "warp mouse to window midpoint".

5. sample optimizations - some systems like to provide a memory mapped global mouse cursor position to keep storms away from window event loops (think gaming mice or drawing tablets with 1-2+ kHz sample rates being forced into relatively small event queues).

There are hacks to work around all these problems but not in a universal "won't suddenly break for your use-case" way. The most common I've seen is simply to make the other mouse cursors into non-decorated transparent windows that they move around, check window underneath the 'fake cursor' and inject into window event queues...

crazyloglad··on LXQt 0.11 Released
Guessing wildly:

1. The linux desktop has been reworked so hard and so many times to try and attract and accomodate those good ol' "my mom uses linux!" as a means of obtaining critical mass for the other things (drivers, well-polished software, ...). The few that this model attract are equally fine with their smartphone and a laptop built around a browser.

2. From (1), it is not even an attractive target for dev- work. I used Linux as a my main "desktop" from the days of downloading slackware over BBS in the early 90ies up until I was introduced to OSX around 10.4. I tried going back after Apple making it increasingly more awful after 10.6. I hated every minute of it - all the things I hated with new OSX was replicated, poorly. an endless stream of internal frustration "no I don't want to automount this usb stick what is wrong with you?", "why is my volume settings jumping around", "yes I plugged in a device, I don't need to be notified that I did what I did please shut up", "oh so two audio feeds with different sample rates are a no go?", "my mouse is low on batteries? I'm not using it, it's not even connected?", "hotplug monitor? enjoy panic and reboot", "I know there's updates to be had, there's always updates to be had, fuck off - daddy's working". I waste more time turning things off than I previously ever had to do turning things on. Now my (non-NIH) regular linux desktop use is confined to VMs that I just reset from template, do my thing and then murder.

3. Not even 'cool' anymore. The 'fragmentation' of the desktop was an attractive feature to young me. Jumping between WindowMaker to Enlightenment to KDE opened a lot of ideas as to what this thing could be used for, I enjoyed tinkering (still do, but not on this chimera). Now they are all convering into mostly the same confused pig but with different shades of lipstick. The same useless animations and effects and none of the useful ones.

"We" lost the mobile race (and never really took to participating) and payed the price with what is effectively a kernel fork. There's a good chance that VR can actually turn into the next "Desktop" (displays are nearly there, eyetrackers, haptic gloves etc. incoming) to make the browser look more pathetic. How many projects are seriously working on it, or is that already lost?

crazyloglad··on SteamVR Tracking
great! One big annoyance with all the SDKs fighting it out right now is how much extra (and often closed source) junk they pull in that replicates things you likely already have, with quite invasive integration with your rendering pipeline to boot. Access to lower level primitives rather than integrated solutions is definitely a nice thing.
crazyloglad··on Google’s QUIC protocol: moving the web from TCP to UDP
UDP based and Encrypted from the get-go? sounds like Daniel Bernstein, ~6 years ago..

[1] https://curvecp.org/index.html

[2] https://www.youtube.com/watch?v=K8EGA834Nok

crazyloglad··on HTC Vive Headset Nearing 100,000 Sales
There's code paths in the driver for artificial vignetting - likely added as a means for reducing risk for motion sickness in fast moving scenes. If those paths are activated erroneously (there's quite a few bugs transitioning between game and menus)
crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
seems we've hit some magical > reply depth limit. I'll get back to you via the gmail account in your "about".
crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
QEmu integration just started working, https://github.com/letoram/qemu it's far from complete enough that I'll try to upstream patches. -display arcan.

Your GPU is most likely fill-rate limited. Are you running this entirely natively (EGL/GBM/KMS stack) or using SDL through X? In the latter case there'll be so many fullscreen sized buffer copies that your GPU cries. There's more special tricks I can do to get the fullscreen case to go faster, and it's on the near todo for Durden anyhow.

Also, the terminal emulator only really supports truetype fonts (there's a built-in fallback that is quick, but it's awful and only 7bit ascii..), which is damn expensive to render.

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
I have high hopes for the shmif- port to vulkan, as far as I can tell, there's no good way to flag pinned memory as shared and build the shmif around that, but if it was possible it would be predictable synch, controlled colorspace conversion and ... oh well, QEmu integration first :-)

You might be able to reduce the fillrate cost by trying config/system/simple displaymode.. it removes a lot of features but you save at least a full extra renderpass.

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
For some work (not browsing though) I'll go with a Qemu backend that connects to Arcan directly. In fact, I just got that to boot a win10 VM with graphics, mouse and keyboard..

Quick glance at netsurf makes it seem that it would not be that many hours of work to have it use arcan as A/V/I backend, hmm..

After the full-on derp that is WebRTC and WebGL, WebUSB will be the next round of "fun".

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
If you poke me on IRC (letoram, #arcan @freenode) I can probably help you out in using the thing.

I think the hardest I've pushed the shared memory interface is basic computer vision (filtering, 9-segment display OCR, tracking an x-y plotter and some glowing devices) on 8-bit mono 2x1000fps 320x180-or-so cameras. Even then most time was spent waiting for synchronization bottlenecks because of OpenGL2.1 limitations.

you thinking about https://youtu.be/bQlHnW2qCh0?t=1m28s ? so the round-trip time there is gpu-composite -> readback -> vnc-server -> vnc->client -> back to gpu.

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
And it was skydiving, it will probably be changed to paragliding then paraplegic ;D

Not that much work, I got a victim machine that is just some scripts, qemu and VNC. It boils down to a keypress to get a new instance activated and when the VNC connection terminates the image is killed. I still place too much trust in the browser..

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
I actually force myself to do at least some of the development on (no cross-compilation) a raspberry pi for the reason of getting a snappy build-time.

I had even forgot there were instructions like that, outside the technical bits I'm probably the worst person to write helpful guides as the workflow etc. is just so strongly internalized that most of it 'feels' obvious.

Now don't look at the code for generating the FFT (or anything else in the _decode frameserver for that matter), the reason it doesn't update smoother is just how much I don't get along with "lib"vlc, but I added it more as a novelty (spoiler, FFT precision is murdered and packed into a texture and the rest is a shader, it doesn't even synch well).

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
Thanks (+for the typo), I have a few options for funds and for a while I developed an appl for computer vision stuff that supported me. Resources here is more in the 'human resources' category, packaging, configuration management, release management etc. I make enough with my dayjob and I like developing this in the lower- pressure- spare- time spectrum. I have some other hobbies that leave me at risk for serious injury, so it might just happen "naturally".

The posting account was simply because I throw away VMs with browsers immediately after use and I chose a hard to remember password without an email :)

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
HCU will rise again!
crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
Futurama reference ;) https://www.youtube.com/watch?v=VmCqn-DNSA0 though apparently popular enough that some people have made all-rush playlists ( https://www.youtube.com/watch?v=JsKBIBJj-4M&list=PL8BF75E7F0... )

On-topic - definitely a cool project and one that I haven't heard about actually, added to my queue of weekly source-code readings.

I'd also consider DirectFB similar, and another project that I just have in my vaguest of memories (think they used a project-name like Cairo that got google-CVed out of existence from the more recent one) from the 2001-02ish era. They tried to attack X back then, but fell victims to the driver situation (but they had arbitrarily rotated windows!).

One of my stronger personal influences is BeOS though - Compare https://www.youtube.com/watch?v=BsVydyC8ZGQ to https://www.youtube.com/watch?v=3O40cPUqLbU&feature=youtu.be... :)

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
like the dexui look and feel, hmm, that would be about an all nighter with my all-rush mixtape and a two litre bottle of shasta..
crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
from https://github.com/letoram/senseye/wiki

"Background-wise, it is losely mentioned in a rather confusing article I wrote a few years back (search around for Retooling and Securing Systemic Debugging) as part of some thesis work, and later influenced on ideas presented in Voyage of the reverser by Sergey Bratus and Greg Conti, and on Christopher Domas work on Cantor Dust which also takes inspiration from Aldo Cortesis visualization works."

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
The 'you can install linux, arcan and durden and then run normal applications' assertion is correct. That's how I am using it. The screenshots were taken on OSX because that was the only handy thing I could do the video recording on at the time. It's possible to 'test it out' with X/libsdl as a backend.

The actual setup is a bit hairy on most distributions because everything brings in X as a dependency, but I have both Alpine Linux and Ubuntu16.04 running it here without X (or dbus or pulseaudio or systemd or ...) Here [1] is some proof and [2] are my rough notes on how I did that.

The whitelist part is entirely optional, it's only there for really security paranoid stuff later on (sandboxing policies and chain-of-trust starting). ARCAN_CONNPATH=durden /some/bin style 'launching' is entirely possible.

The second to last slide goes into the relation with Wayland, but there will be support for connecting applications that speak wayland, and other protocols for that matter.

[1] http://cubeupload.com/im/lmBeMk.png [2] https://github.com/letoram/arcan/wiki/linux-egl

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
Thanks!

Arcan is definitely written to be used without the Lua parts as well, and on the project timeline the final pieces of the puzzle is libifying the engine. The reason why it is not like that right now is just that the internal engine interfaces are not in a stage where I would 'commit' (and document and test) an interface that others might end up relying on.

I also much prefer statically typed languages, I consider Lua somewhat "the best among the worst". One nice thing with its VM integration API is that it lends itself to be swapped for another VM without too much work rediscovering a type model. If I would have the luxury of more time, binding the engine to Haskell would be high on the list.

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
perhaps needlessly to say, but I agree wholeheartedly ;-)

Personally I hope that when people get past the new-old 'sandboxing will solve security' trend going on, there'll be more people looking at the HCI connection instead of just saying "well its a user problem".

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
I assume that the video you are referring to is the durden demonstration playlist [1] and not the general project presentation?

For durden alone, it's a bit hard to invite the comparison on a level other than feature, since I have to cover the bases that xrandr, xset and a whole lot of other x* tools provide - but current and planned features is tracked in the checklist if you scroll down in the readme at [2]

[1] https://www.youtube.com/playlist?list=PLGqpKIeZOSp6quf6CmMOr... [2] https://github.com/letoram/durden

crazyloglad··on I wrote a display server, a desktop environment, and a debugging/reversing tool
thanks :-) you're right in that the only world it'll likely take over is my own, but I'm quite fine with that - the only device I rely on that it's not the UI for now is my smartphone, but the only thing missing for that is KMS/GBM support.

Amusingly enough, the reason we've been stuck with X.org/Xfree86 all these years is the hard coupling between the graphics drivers and the server implementation - and while different, of course, it is very much like that in Android land too, lower level GPU interfaces act as a very good control and lockin mechanism.

← PreviousPage 2 of 2