Can't the kernel set up hardware-backed memory maps to partially blind itself to other memory regions? (Only "partially" because even then I expect it could just change the mappings, but it's still a protection against accidental corruption)
Yeah that part of the article put a big smile on my face.
I did the same thing back in college, when I was in a lab. We wanted to do some research on Wi-Fi signals, and I happened to own a bunch of Wi-Fi adaptors produced by SomeSmallTech Co. Ltd., which featured relatively new Atheros chips and didn't have Linux drivers at the time.
So I sent an email to the company's public email address, asking for some datasheets, "for science". To my disappointment, presumably a PR person replied that they "don't have a company policy to collaborate with academic research". (But they did send a quick reply, kudos to that.)
Funnily enough, years later I ended up working for said company. Naturally, when I first logged into the company network, I searched for the datasheets I asked for. There were "classified" watermarks all over the PDFs :)
Built on top of Owl Lisp[1]. TIL about this dialect, and it looks interesting! Instead of native threads, it has continuation-based threads[2], and it seems the whole VM architecture is based on that.
> Having tiling options that fit within a smaller part of the screen (e.g. still allow side by side or top/bottom split, but in a smaller total region) would be great.
Do you mean reserving screen space for the on-screen keyboard? If that's the case, you can try to "transform" the top-level frame (a frame that tracks a monitor's screen area), either in the REPL or in your config: https://agent-kilo.github.io/jwno/cookbook/adjust-top-level-...
> Using example-config.janet I tried pressing RAlt or RAlt+K and I get the UI hint shortcuts list coming up, but none of them seem to do anything
Can you please file a bug report and attach relevant logs? You can write logs to a file by starting Jwno like this:
There should be some interesting logs when you press one of the UI hint shortcuts.
> Fwiw, as a newbie I found it a bit intimidating/off-putting that it doesn't work out the box without choosing a config file. That's quite a lot of extra cognitive effort and link-clicking before you can try it out.
I totally understand. But I chose to not include a default config in the executable, because I thought a window manager is a... personal thing. It should evolve with your habits and workflows, so the default config will most likely get changed to something dramatically different anyway. I can be wrong though.
Yes! transforming the top level frame sounds like the way to go.
I ran jwno with example-config and pressed RAlt and RAlt+K a few times, each time trying one of the onscreen shortcut keys (b, c, d, etc). Log at the bottom of this comment. At the end of the process I was left in a state where pressing Space triggered a context menu in my title bar, and I couldn't type space in the app (e.g. in Notepad or Terminal) which I think is due to one of the Alts ending up being held down? It persisted after leaving Jwno
Thanks, that's it. I really like 'gradually walk the UI tree', though I'm struggling a bit with the thing I want being obscured by the label (and me not remembering what was there). An offset would be nice, though I'm sure it's not easy to define a heuristic that works in all places.
The first thing I tried was in my browser, I asked for all the buttons and it labelled the 'x' to close each tab, but where the labels were laid out it just looked like an inviting right-aligned label on the clickable tabs themselves. Lost a few tabs before I realised, because you also don't see any feedback on the click since any UI feedback is hidden by the label. Hmm. Food for thought.
> An offset would be nice, though I'm sure it's not easy to define a heuristic that works in all places.
I agree. I considered dynamic offsets, in an effort to declutter the labels, but found it even more confusing. Maybe I should do more experiments on this.
> but where the labels were laid out it just looked like an inviting right-aligned label on the clickable tabs themselves
The labels are left-aligned by default (except in `frame-hinter`). I think you can try some combinations of the `:anchor` and `:show-highlights` options[1] to see if they work better for you.
Meanwhile you can try to change leading `RAlt` to something else, like `Win + H`, and see if it works. There may be a bug that gets triggered when only modifier keys are mapped.
My StumpWM is heavily customized though, and I mostly modeled Jwno's behavior after my own config, so it may not be what you expected at all.
But that's one of the reasons I like Lisp and things built in Lisp: They are so flexible, you can sometimes build something based on the original thing, while it feels completely different from the original.
> my monitor seems just the right shape/resolution for the standard Windows splits to be suboptimal
Do you use an ultra-wide? In that case, Jwno has no OOTB ultra-wide support, but there's a section for adjusting it in the cookbook[1].
> Do you use an ultra-wide? In that case, Jwno has no OOTB ultra-wide support
Actually no, I'm using two regular, 16:19, 2560x1440 screens. It's more that my understanding of readability does not agree with what designers think, and when I split the screen in half, many pages end up with text a little too small for my comfort, and if zoom in to compensate, the lines get slightly too short or horizontal scrollbar appears.
(I'd guess it's probably my somewhat strong myopia glasses that are getting me "out of alignment" from average user when it comes to text size and line length preferences.)
> but there's a section for adjusting it in the cookbook[1].
Lovely!
FWIW, I took it for a spin briefly (only briefly - had work to finish, but I plan on getting back to it) and I was pleasantly surprised by how good it is, and how well it handles Windows quirks. It feels nicer than StumpWM did back when I used it. The only thing that didn't work well was VLC - it does something weird with recreating its window when switching between videos, and in the process, it "breaks out of confinement" and ends up returning to original size and position it had before Jwno took custody of it.
Sorry for the confusion. Multi-monitor support is only briefly mentioned in the docs[1] and the interactive tutorial[2].
Jwno's internal data structure has these levels (higher-level comes first):
Root - Virtual Desktops - Monitors - Normal Frames - Windows
So monitors are part of a virtual desktop, and every virtual desktop has the same layout that reflects your physical monitor arrangement. When you switch virtual desktops, all monitors switch to the new desktop at the same time.
It's a quick-and-dirty PoC with lots of caveats and limitations though. E.g. it works only for a single monitor. I don't think we can clip windows to a "view port" on Windows (the OS), so this may never be as nice as PaperWM, Niri etc.
I think these are the most obvious differences between the two:
* By default, Komorebi uses dynamic tiling, while Jwno uses manual tiling.
* Komorebi has workspaces, Jwno works with Windows native virtual desktops instead.
* Komorebi uses IPC and native system command line to send commands, while Jwno usually operates all by itself.
There are definitely other details that are important to you, but these are the things that immediately came to my mind. I don't run Hyprland so can't really comment on that.
I think Janet is quite...liberal? It's a practical language, but doesn't force a specific paradigm on you. There're "escape hatches" in different levels of the language, and I like that.
Maybe the most "opinionated" things in Janet are the ev stuff and fibers. I think they're done right though, you just need to be careful with the event loop when embedding Janet.
Strictly better unless you need an extremely small runtime rather than a very small one, or are exposing a scripting API to users who will recoil from prefix notation.
I find the REPL and interactive development workflow invaluable. A window manager is a long-running background service by nature, and has a lot of accumulated runtime states. The ability to peek inside and debug while the process keeps running helped me a lot when building Jwno.
I think Jwno's REPL module is so important, I specifically changed Jwno's architecture at one point to make it work.
> I find the REPL and interactive development workflow invaluable. A window manager is a long-running background service by nature, and has a lot of accumulated runtime states. The ability to peek inside and debug while the process keeps running helped me a lot when building Jwno.
Sure, but any particular reason you picked Janet over Common Lisp? They both support images, REPL, hot-code-reloading, etc.
TBH I dived right in when I decided I should build something with Janet, and didn't really consider any alternatives. Now you mentioned it, I think Janet's simplicity and conciseness played a large part in attracting me to it, comparing to Common Lisp at least.
Janet being a tiny embeddable runtime similar to Lua probably makes it perfect for a use-case like this. You have a full language, standard library, and interpreter in ~1 MB, along with the ability to bundle the runtime with your scripts into one binary. That's worth a lot.
I am not familiar with Janet but have been a long time lisp developer. Could you perhaps add a few lines to the readme explaining how the build process for jwno works? Would love to give it a try, understand how it works and hack around :)
I think the architecture assumes all loaded kernels are trusted, and imposes no isolation other than having them running on different CPUs.
Given the (relative) simplicity of the PoC, it could be really performant.