Show HN: A Tiling Window Manager for Windows, Written in Janet
agent-kilo.github.ioHi HN!
I read[1] about Janet[2] some time ago, then immediately got impressed by the enthusiasm of its community, and by the language itself, so I started playing with it.
At the time I was searching for a tiling window manager for Windows, and unavoidably the idea of scratching my own itch with Janet got hold of me, so Jwno was born.
Simply put, Jwno is a keyboard-driven tiling window manager for Windows, scriptable with Janet. But since it has a complete Lisp runtime, and a thin wrapper library for Win32 APIs[3], you can certainly do much more with it.
I hope you'll enjoy playing with it as much as I enjoyed building it.
And yes, I use StumpWM on the Linux side, by the way.
I'm curious, did you find there were things that were easier to do because it's Janet/lisp-like language? Or you just fancied like using it (perfectly valid reason of course!).
I tried various lisp dialects, but I could never find the killer feature vs other languages I already use. And I can justify why I use these specific languages I do use, if that makes sense.
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 could never find the killer feature vs other languages I already use.
You're kidding or trolling? Structural editing and the REPL are the greatest features of Lisp. The ability to just grab any expression and move it around simplifies so many things when coding and refactoring. With the connected REPL you can eval anything on the spot, that turns the entire experience of coding into a video game — you don't need to wait for linter, linker, compiler — you just run things. You often don't even have to save anything. I suspect when you "tried various lisp dialects" maybe you didn't use structural editing and the connected REPL?
Often people confuse Lisp REPL with REPLs in other programming languages, e.g. Python, where usually you have to copy-n-paste chunks of code into it. Lisp's REPLs are different in the sense that every step in Read-Eval-Print-Loop is different — in Lisp, you typically eval things right where you type them, by sending whole expressions to the connected REPL, which could be remote. We (for example) run ours in a Kubernetes cluster, that allows us to experiment with pods, running queries against the "real" DB tables, testing services "live".
> You can implement custom commands and hooks to trigger. It's even possible to call native Win32 APIs in your own implementations. For example, to always move a Notepad window to the (100, 100) coordinates on your screen(s), using the low-level SetWindowPos function
Great job. Looks really interesting and useful. And a fun excuse to write Lisp.
I really appreciate it when APIs give you high-level functionality but keep the door open to lower-level APIs when you really need them.
Janet looks really neat. And this project seems really cool. Windows DESPERATELY needs a more powerful built-in manager. It's ridiculous to use the mouse all the time.
One of the later PowerToys updates makes the first few steps in the right direction with "fancy zones". It's not strictly native windows, but still developed by Microsoft and adds keyboard shortcuts for all its utilities
PowerToys seems to be making two step forward, one step backwards, and then makes a leap in a random off-axis direction. Every time an update comes, I feel both joy and worry - I expect to see some new cool thing (and possibly even useful to me), but I also worry about bloat and random performance degradations. I haven't bothered with measuring and quantifying it properly, but I do feel PowerToys got heavier and slower over the last 2 years.
Ironically, 90% of use I get from them is remapping Caps Lock to CTRL. Which I historically did with AutoHotkey, which was much lighter, but then there's the 10% of the time I need something else from PowerToys...
Even lighter than autohotkey is remapping on the hardware of the keyboard. There's a lot of open source firmware options for that now in the custom scene
The even simpler solution to remapping Caps Lock is to use SharpKeys, which applies registry settings to make use of Windows’ built-in remapping functionality.
TIL: SharpKeys
TIL: Windows has a built-in remapping functionality
TIL: That functionality is controlled by registry, meaning I wouldn't even need a tool in the first place (I've learned to write REG files as a kid).
Thanks!
I never use the mouse to move windows around, windows key + arrows key meets my needs fine even multi-monitor, breaks the screen up into halves and quarters. Alt-tab to change focus.
> Windows DESPERATELY needs a more powerful built-in manager. It's ridiculous to use the mouse all the time.
And yet, I find Windows window management far more advanced than macOS. It's ridiculous that up until recently, macOS didn't even have basic max-size functionality w/o reaching for 3rd party apps.
Whoa, very cool. I love WMs, I love Lisp, and I hate Windows. This seems to be a perfect "medicine" for my frustration with it.
Long-time StumpWM user, before I switched back to Windows a few years ago. This is super-exciting to see, and I'm going to take it for a spin. It might just address my major frustrations with arranging windows and switching between them; my monitor seems just the right shape/resolution for the standard Windows splits to be suboptimal.
(Browsers, in particular, I use full-screen less and less. That annoying trend of squeezing everything into short lines "because readability" is just wasting too much screen space; zooming in makes everything too big, and I'm getting tired of writing userstyles or userscript to fix it for every other page I open, so I'm back to keeping 2 or 3 columns of windows running.)
Also, any excuse to use more Lisp is good in my book. Based on the screenshots, it looks stellar; if it works half as well as it comes across, I'll switch over instantly.
A fellow StumpWM user!
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].
[1]: https://agent-kilo.github.io/jwno/cookbook/adjust-top-level-...
It's not a tiling manager but slightly related: I replicated Spectacle/Rectangle (macOS apps) on Windows a while ago to snap windows to edges/corners/two-thirds/one-thirds etc a while back. If you're interested: https://github.com/ahmetb/RectangleWin/blob/main/README.md
I love Rectangle, will definetly check this out!
That UI hinting feature is killer. Is something similar available outside of this repo?
I agree, it's impressive. It brings me back to early Windows when keyboard control was a first class citizen in the UI, and most functions had dedicated alt key combos per dialog.
What kinds of automation are possible with having a scripting language inside your WM, rather than Sway-style IPC? I heard the new Windows WMs were where most pure workflow advances happen, so I wonder if they can be replicated on Linux.
Looks very good! This one is what I need
I recently tried hyprland after using xmonad for like 10+ years and wondered about the decision to bind workspaces to displays. I didnt like that. How does Jwno handle multiple monitors? I have looked at the docs and didnt see it mention anywhere.
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.
[1]:https://agent-kilo.github.io/jwno/frame-tree/frame-nodes.htm...
[2]: https://github.com/agent-kilo/jwno/blob/master/example/tutor...
This might be the coolest project I've seen using Janet yet!
Jwno is great, agentkilo is kind, Lisp is magic :)
Thanks for the kind words! It means a lot coming from you :)
Oh ! That looks cool :)
Thanks :)
Custom windows shells (I know this is just a window manager, but still) in the year of our lord 2025? This takes me back to the days of installing bb4win and litestep in XP. I'm a kid again!
flashback, 2001. I'm 25, sitting in the office with litestep installed (which honestly was the only alternative to Linux or resignation). My five years younger colleague steps up to my desk and says "hey, cool desktop!"
I start explaining, very carefully, like I'm talking to a child, that this is an alternative shell, which replaces the standard Windows Explorer et cetera, und so weiter... it's very complicated you know...
Guy says, "cool... hey, why don't you check out this URL?". I do. It's the litestep contributor page. His nick is on it. Near the top.
Ow.
First part of your story reminded me of when I once trolled a non-tech savvy friend by running Windows in a VM on Linux, and told him "have you ever seen what's behind windows?" then I exited full screen to reveal a desktop full of terminals running the matrix digital rain.
TIL bbLean [1] still works in Windows 11! Currently digging through my archives for my old BB4Win styles repository
[1] https://bb4win.sourceforge.net/bblean/
Wow, bb4win and bblean take me way back. In fact, they were a huge inspiration for my shells[1] feature, which are just userland programs that happen to be able to manage panels (windows).
[1] https://90s.dev/technical/architecture.html#shells
Is it just me or did not a single one of those "l33t haxker shells" ever produceable a single ui innovation that lasted?
I mean, I remember there being a whole ton of wildly customized windows shells with menus and floating terminals and so on, but not a single thing stuck around?
I'm not sure about the Windows scene, since I only toyed around with one or two shells nearly twenty years ago, but the motivations for creating windows managers in Unix varied. Quite often they were about the appearance, customization, ease of customization, lack of customization, or low resource usage. I suspect that most of them were made for the learning experience or simply as a form of self-expression. They were never really about innovation. When there was innovation, it was usually in the form of small things like how we size and position windows (e.g. think about how it is possible to tile windows in Windows these days).
Besides, the term innovation is used far too much with respect to software, in the sense that a lot of stuff can be traced back much further than the so-called innovators will suggest. Many ideas have deep roots, but it took several (often independent) attempts until the technology or its users were ready for it.
Sloop manager for replacing progman.exe in windows 3.1, for me..
>litestep
Brings back memories !
Oh shit yes: Rainlendar
This is so cool! It's funny because open source devs are making Windows better while MS is actively making it worse. If MS removed all telemetry and AI (and restored win10 functions in context menus), I would probably move back to it.
I've recently started playing around with Janet, and it's a great language. I think it's inspired by Clojure and Lua, and somehow manages to be better than both (in my opinion).
> I think it's inspired by Clojure and Lua, and somehow manages to be better than both
This is exactly how I feel about Janet too. I don't think I have enough experience on Clojure or Lua to comment on them, but I got attracted to Janet almost immediately.
Working on Jwno also confirms my first impression on Janet: It's really a practical language. The tooling has some room for improvement, but the language itself can get things done - usually fast and easily.
Agreed on the need for better Janet tooling. I'm trying to be the change I wish to see with Janet LSP[0]. Issues and contributions are welcome!
[0] https://GitHub.com/CFiggers/janet-lsp
How’s the REPL/interactive editing story? I feel weird using a Lisp that is not as interactive as Racket, Scheme or Common Lisp. Running scripts from the REPL ain’t the same thing as C-x C-e an expression on a live program
> I feel weird using a Lisp that is not as interactive as Racket, Scheme or Common Lisp
I think Racket and Scheme don't belong in there because neither has a REPL as powerful and "interactive" as Common Lisp REPL. They don't support images either (but Janet and CL do).
As a Common Lisper with a Scheme background I'm gonna guess that by the interactivity of the REPL you mean the condition system with restarts? While most Schemes don't really have anything like it, I seem to recall MIT/GNU Scheme having something kinda similar. And I mean, hey, it's got Edwin, so it definitely has interactivity.
Yes, I mean the conditions and restarts system in CL. Haven't seen anything like that in Clojure and other Lisps.
Yeah, it's mind-blowing when it clicks, and makes the whole "exceptions vs. return types" discussion look like a quarrel of 3yos in a sand box. Error handling in other languages/runtimes just doesn't feel sufficient from now on.
This is, of course, just a part of a larger whole - the fact that your Common Lisp program ships with a compiler it can access and effectively always runs in an edit-and-go debugger. Embracing this fact fully leads to a different workflow of software development.
Having done a bit of that, I found plenty of drawbacks of this approach, too - mostly various consequences of breaking the assumption that code that a program is running is the same as the code it was compiled from or that it started with. The aspect that annoyed me the most day-to-day was, basically, that whenever I fixed something on the fly through conditions and restarts and eval-ing code in a REPL, I never had a nice way to go back to that solution and port it to code. It was too easy to forget about a quick fix you did without thinking.
I now realized this should be easily fixable with external tooling - i.e. in Emacs/SLIME. What I think they need is a better way of keeping an audit trail. Capturing and persisting as much of the transient interactions you did as possible, letting you revisit them after and easily transfer into code or tests.
> I now realized this should be easily fixable with external tooling - i.e. in Emacs/SLIME. What I think they need is a better way of keeping an audit trail. Capturing and persisting as much of the transient interactions you did as possible, letting you revisit them after and easily transfer into code or tests.
To some extent, undotree on neovim allows this because it offers a drastically different view on what "undo" means. But I agree with you, the lack of a git-like system is annoying. I even think this might be THE reason CL didn't catch on—companies want to keep track of things (hence all the dashboards and ticketing systems...).
There's multiple dimensions you can slice and dice the Lisp family by. Images and REPL experience are two big ones, but they're almost orthogonal.
I didn't mean that Racket and Scheme aren't Lisp (they are!). I meant they don't have the images and REPL-driven development of Common Lisp.
If we're still calling Guile a Scheme (I'm out of the loop) then I don't know, it gets really bloody close. Not so much in image-based development (that I've usually found less good than a decent packaging system because the contents of my files on disk is usually more tractable than the contents of my image), but its object system and error handling are definitely up there close to CL.
I mean, Common Lisp is still the gold-standard for me, but reading about Hoot recently really made me want to check Guile out a bit more (CL does not have much in the way of lovely WASM stories right now) and, honestly, I was super impressed. I think if the interactive experience of developing in Hoot in the browser matched the interactive experience of developing in native Guile, I'd be a pretty happy convert.
This is how I feel about Janet too, absolutely practical. So far it's been a breeze to write the little experiments I've done so far.
This is a fantastic replacement for Windows Explorer which is about 10X faster/lighter:
https://filepilot.tech/
(it's beta so it has a few little annoyances still)
Tangential but I’ve been writing a lot of Janet recently using Joy[0], web framework, to build a small web app. Would love to hear what you learned about Janet from doing this work and how you feel about the language afterwards.
The one thing I’ve noticed is that it seems like Janet had a burst of interest 2020-2022 but it has since slowed down. Would love to see it become popular again. The main reason I’m using it is because I like how it’s both powerful and lightweight. I’d use clojure but I don’t want Java. I’m tempted to also try Common Lisp but so far Janet has been great.
[0]: https://github.com/joy-framework/joy
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.
How it compares with Lua?
If you like Janet and Lua, might as well try Fennel, which was made by the creator of Janet.
I have read about Fennel many times and considered on trying it - I didn’t know that they have the same author!
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.
This one actually has real arrays (mutable and immutable)
I always disliked the chaos that happens quickly with application windows, and loved the idea of tiling. But none of them really worked for me practically until I found PaperWM around a year ago or so (gnome extension). It has few core shortcuts and feels more natural. Like you would really arrange applications directly on your desk. It does not limit itself by your screen width and has the nice default that a new window appears to the right of the current window (configurable). You seldomly have the need to re-arrange windows, because the default just fits 99% of all cases. In addition, you still have the comfort of gnome. No hacky config files just to get wifi working or so. For work we have OSX, and I am really missing it there (I am using rectangle there instead). https://github.com/paperwm/PaperWM?tab=readme-ov-file#usage
Jwno can do this! https://agentkilo.itch.io/jwno/devlog/871672/scroll-jwno-scr...
Thanks for posting the link!
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.
Neat! This looks pretty close, at least for the base principle. If I had a windows machine I would definitely give it a try.
scrolling window management is a new paradigm for me - really liking paper so far, thanks for sharing! (for what its worth, traditionally my approach has been fixed window positions for all applications, and enough screen real estate to support that. but that doesnt work in wayland with any mainstream compositor afaik)
How does it compare to komorebi? I've been using it for about 5 months with great success. I'm a Hyprland user when I'm on my personal machine, but for windows Komorebi has let me keep my muscle memory and workflow largely intact.
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.
Just in case someone new is looking, komorebi is great:
https://github.com/LGUG2Z/komorebi
komorebi dev here - Jwno is awesome and I highly recommend people give it a try (especially people who enjoy writing Lisp!)
The Windows tiling window manager development scene is a very kind, relaxed and collaborative space where we all take inspiration from and support each other
That is amazing and I hope it'll continue to be so :).
The Linux scene isn't bad either (or at least it wasn't 4+ years ago when I was into this); I've used StumpWM as a daily driver for many years, and while it was definitely niche, I still saw friendly exchange of ideas and experiences with people using and/or contributing to dwm, i3, and ratpoison.
(Then there's EXWM, but I never really mustered the courage necessary to try it.)
Definitely! I got great inspirations from both of the Komorebi and GlazeWM communities. People who like tidy desktops are definitely nice people :)