StumpWM 1.0 Released

Easily implemented in AwesomeWM

Edit: Actually, most all of this could be implemented in X11 keybindings outside of your window manager. Just the full screen part that the WM is needed for. And that can be implemented in any WM and probably most DE

I wonder if you could configure StumpWM to use vim-like leaders? http://stackoverflow.com/questions/1764263/what-is-the-leade...

I'd love to be able to "right-windows o f" right windows is the leader key, o would be open, and f is for firefox. "right-windows o c" to open chrome

>I cannot have this workflow in any other tiling window manager!

I could easily replicate this in bspwm+sxhkd with a small script.

I'll join the bandwagon and say it's also done without any problem in xmonad :)

But yeah, after switching to tiling WM and configuring it properly there's no going back.

Easily done in ion3

This is also doable with fvwm.

You should have a look at Sway. It's a Wayland i3-alike with a few extra features. It even plays nicely with X11 only applications via X-Wayland.

http://swaywm.org/

> Wayland is just super nice compared to X11 for enough tasks to justify using it.

I'd like to hear what makes it better for you in terms of day-to-day experience. I can look at feature lists, but those often don't give a good picture of the reality that people experience. Given your enthusiasm for Wayland, I'd like to hear it!

> Seriously though. Someone please make a good, working Wayland tiling WM.

There's https://github.com/Immington-Industries/way-cooler

It's alpha, but gets extra HN brownie points for being written in Rust.

I want to use Wayland, but it breaks a few tools I use (Autokey [0], marathon [1]) as they depend on X-specific tooling/APIs (for marathon: wmctrl, xdotool). So I'm disabling Wayland for now even though I'd like to use it (for starters, simply to roll with GNOME's boat, since Wayland is the default on Arch).

--> Are there Wayland equivalents to wmctrl and xdotool? Any plans for them? If no, does Wayland provide a complete-enough API to write similar tools for Wayland?

[0] https://github.com/autokey-py3/autokey

[1] https://github.com/ronjouch/marathon

Is Wayland actually that much nicer than X11? Like, I know the architecture and code and nicer, but as the end user, do you actually experience anything different?

I've found that to be true in general for Common Lisp projects.

With StumpWM, it's nice in terms of finding where certain functionality is implemented so I can rework it in my ~/.stumpwmrc. Having easily-accessible source code was invaluable for me adding gaps between tiled windows (and has helped me get 90% of the way done with adding a second modeline to hold WindowMaker-style dockapps).

that's probably https://stumpwm.github.io/git/stumpwm-git_7.html#Mode_002dli...

StumpWM is manually tiled, ish. It's based around splitting panes into smaller panes (rather than the fully-manual approach used by, say, subtlewm), but it's separate from the process of opening a program, so by default new windows will stack on top of one another until you split and/or move them yourself.

One consideration might be which Lisp you're using. SBCL is known for its speed compared to other CL implementations, for example, so using it (especially now that it's the one recommended Lisp to use with StumpWM) might help considerably.

I personally don't notice any significant performance issues, even on old single-core 32-bit hardware.

As user of i3 and not having tried StumpWM what makes splitting windows easier in StumpWM?

Have you tried ratpoison? Same author, but in C, so it's fast.

They actually manage your windows.

The tiling part of it isn't the important bit: what's important is that they keep your windows placed in a useful manner for the task you're performing, tiling in various ways being one of the ways in which they achieve that.

Normal window managers are akin to a desk where everything is tossed around, whereas tiling window managers are like desks that automatically organise whatever is on them.

If you're using Linux, it's worth just trying one. On OSX, it usually means running X11 instead of the Mac display manager which is usually not really a great thing. If you're using Windows, the options are worse.

For me, the advantages of a tiling window manager [xmonad] are:

1. Keyboard control of app switching that is easy to setup in a 'habitual' configuration yet flexible enough to change on the fly.

2. The ability to quickly switch via keystroke to and from full screen views of an application. And when I switch via keystroke from the full screen view to a view of multiple applications the multiple application view is presented in a sane and consistent way right away.

3. The ability to switch via keystroke immediately to a view of two or more applications side by side or one above the other.

There is a learning curve and as with all things that occur up until the year of the linux desktop, there is a configuration curve. But basically, a tiling window manager lets me make my windows dance to whatever tune I choose.

There are many, here are two of my favorites:

- I can completely disable all controls, notifications, status bars and the like. This leaves me with less noise and allow me to focus on the applications at hand. But usability does not suffer, I can display whatever information I like, when I like with a simply shortcut. F.e. If I need to take a look at the date I just hit `C-t d` and it shows up.

- I can assign shortcuts to applications. For example, wherever I am, whatever is on the forefront I can hit `C-t f` and Firefox will show up, I hit it again and it will go to another Firefox window if there is one, terminal is `C-t c` and so on. I stop doing window management altogether and work on higher level.

Note also that StumpWM does manual window management, while it sounds tedious, in fact it is a delight. You have all your stuff exactly as you like it without the WM trying to guess anything.

What a tiling WM does in this situation is remove the part of the equation where you have to think about maximizing your windows. Instead of mouse interactions with GUI controls for window placement and scaling, you just use a couple of hotkeys to cycle between window layouts and navigate workspaces (i.e., if you want side-by-side windows for a moment during some task, you hit a key once or twice, then do the same to get back to maximized windows). This may not seem like it's much cognitive load to get rid of, but for me at least, going back after a few months of having the WM just handle things felt clumsy and primitive.

It will also ruin you for using most standard desktop environments, and I personally burn probably a solid day a year porting my WM config to some new environment. These have been a worthwhile trade-offs for me, but probably something to consider if you have to use systems you don't control very often.

Your windows will never overlap. If you always have your windows maximized, then you can definitively benefit from a tiling window manager since it will always open new windows maximized.

I also have my windows maximized and have each window assigned to a different workspace. Switching is as easy as pressing alt + 1, alt + 2, etc ... (in i3wm)

It's kind of like having everything maximized, but more flexibly. For example:

* You can have two editor windows "maximized" into two halves of your screen, letting you compare things side-by side

* Expanding on the above, my typical development workflow on my laptop is to dedicate one half to an editor window, then split the other half, with the top for git (I use Emacs w/ Magit) and the bottom for a terminal window (usually for actually running my project). I'll then add editor windows to the left half and terminal windows to the bottom-right as needed. All windows are maximized into their little compartments.

* Your "maximize everything" workflow is actually the default in StumpWM (which doesn't split windows unless you tell it to split windows), and is how I typically work when I don't need to be viewing multiple things at once.

The main advantage I find is that I don't need to use the mouse to manage my windows. I split my screen to have my emacs session and terminal/browser etc., side-by-side. I can move the windows using key bindings: snap them, split the screen etc.,.

Also extremely light-weight when compared to DEs like Unity/Gnome.

Maximize stops to make sense at some point when your screen gets large enough. You can have at least two windows side by side and maybe a console below without having to sacrifice some sidebar in your IDE or whatever.

I have the habit of maximizing the browser on windows, but on most pages that leaves a lot of empty space to the sides that isn't used anyway.

Under i3 on the other hand I keep the browser on maybe 1/3rd of the screen width because managing the whole layout (not just one window at a time) is so much easier.

And the alternative, overlapping/floating rarely seems useful for me.

They're simpler than desktop environments in every way.

I have found that I use 10% and absolutely require 0% of the larger DEs' features, so using a simpler system makes sense.

Your use case seems like it would work well with tiling window managers, since you can just arrange things so that you have a single fullscreen window per workspace.