arisuchan    [ tech / cult / art ]   [ λ / Δ ]   [ psy ]   [ ru ]   [ random ]   [ meta ]   [ all ]    info / stickers     temporarily disabledtemporarily disabled

/tech/ - technology


formatting options

Password (For file deletion.)

Help me fix this shit.

Kalyx ######

File: 1492542438951.png (220.25 KB, 1280x801, dwm.png)


How do you think Awesome and i3 compare? Granted, their problem domains are slightly different, but as Awesome was once the king of the ricer WM and i3 currently is, they are worth comparing.

I used to use Awesome. However, I eventually realized that I didn't really have the drive or skill to do anything interesting with it, beyond very basic tweaks. The next time I felt the urge to distro hop, I ended up switching to i3. I found its configuration system somewhat limiting compared to Awesome's, but I don't think that's a flaw in i3, because I've been using it for about six months now. Let me explain why that wasn't a problem.

Awesome is very much like Emacs in design philosophy. Emacs not only provides the facility of a text editor, but also an entire scripting language and a broad range of tools to extend the editor with. In effect, it's an IDE disguised as a humble text editor. Awesome, similarly, not only provides the facility of a window manager, but also an entire Lua implementation and a set of extensions to extend its window management functionality with. Like how Emacs is an IDE disguised as a text editor, Awesome is an entire desktop environment disguised as a window manager. A sufficiently tooled Awesome setup not only offers window management, but also offers a panel with a system tray and its own native widgets, a notification daemon, and third-party extensions that doubtlessly incorporate further functionality. The end result is something extremely flexible, but also massive and complex. Consider the following code, found in Awesome's default configuration file [1]:

awful.key({ modkey, }, "j",
function ()
awful.client.focus.byidx( 1)
if client.focus then client.focus:raise() end

This code snippet makes Mod+j switch focus to a different window. To do that, the user must separately declare the modifiers, the regular key, and an anonymous function that carries out the action. This complexity is good, in one sense, because it allows the user to turn complex actions into simple keybinds. But in another sense, it's terrible, because one of the simplest parts of window management can only be implemented with several lines of user-written code!

If Awesome is like Emacs, then i3 could be compared to Nano. Nano provides very basic text editing functionality: search and replace, undo and redo, cut copy and paste, and syntax highlighting. Nano is configurable, and the DSL its dotfile uses is simple. Nano lacks extensibility, however; there's not much more to it than what's offered on the menu bar at the bottom of the screen. Although habitual use of Nano is frowned upon (often for frankly elitist reasons), even among users of more advanced editors it has a reputation of being easy to use, and good in a pinch. Now, before we get back to i3, imagine, for a moment, a version of Nano that worked well with Unix pipes, such that one could pipe the output of a command into Nano, do a few quick edits, then pipe the results into another command. Despite how limited Nano per se is, its lack of inherent extensibility could more than be made up for by the powerful text processing tools that the Unix environment provides; after all, simple text editing tasks would be all it needed to do to excel! This is where we find i3. i3, too, has a very simple configuration file with a (compared to Awesome) limited set of commands, all of which relate directly to its core functionality. It also has simpler window management capabilities: it can move windows between and around workspaces, but unlike Awesome, it can't place tiled windows above floating windows, create window buttons, minimize windows (without a hack), or do many other things. However, unlike Awesome, the i3 developers expect and encourage users to combine i3 with other utilities. i3, by default, does not have an application launcher; its default configuration offloads this task to dmenu [2]. i3 ships with a taskbar, but i3bar is shipped as an independent utility, which merely takes an arbitrary status line and outputs it on an X display, and also provides a system tray and workspace list. (It lacks a window list.) Be default, i3bar takes input from another independent utility, i3status; however, the i3 documentation encourages the user to replace i3status with another status line utility, such as Conky. The lack of extensibility i3 can and should be compensated with through the use of other utilities, and thus the user sacrifices little or no flexibility. (i3-msg provides further flexibility, but pales in comparison to Awesome's Lua API.)

As a side note, another major difference lies between the tiling functionality of both window managers. Whereas Awesome provides a set of defined "layouts" that the user can apply to a workspace, i3's container system provides the user an immense amount of flexibility in positioning their windows. Several constructs in Awesome's API for arranging windows are totally unnecessary in i3. Although Awesome's layout system allows users to quickly change the layout of windows on the fly, and also allows greater ease in their initial placement, i3 easily beats it out in sheer flexibility.

[1], lines 169-173
[2], line 44

All the above said, I'm curious to see people's opinions on the differences between Awesome and i3. I'm also interested in comparisons between Awesome and Xmonad; their problem domain and design are much closer to each other.


my impressions, having used and abandoned both for greener pastures:

i3 is an entry-tier drop-in-replacement-blob that's great for somebody who wants an install-and-forget replacement for X DE's window manager, but it quickly starts getting in the way, with annoying defaults and pointless features to wade around, if you start trying to customise it.

awesome is a bad hack built on an ever-shifting pile composed of an ugly language and held together by bits of duct tape that sometimes stick out into nothing because the neighbour-pile they were supposed to connect to has since disappeared. it "can be extended", but doing so is impossible in practice for anyone who treasures semi-sanity.

so, overall, would say i3 is an improvement, what with the being less likely to randomly break or explode.



…as for your editor analogies, anybody who "really uses vim" (i.e. knows how to use buffers and doesn't open everything in tabs like a doofus / never touches the arrow keys) will be confused to all heck when typing visudo, hitting C-d, having nothing happen and then accidentally typing a bunch of js and then having some search bar thing appear when trying to erase them with C-w and the bar doesn't appear when hitting Esc and then will freak out and C-c and at least that made the bar go away and then just sits there, dumbly, for a second, before either hitting C-f or maaaaybe remembering that arrow keys exist and trying that then finally typing in the right thing in the right spot and hitting : and then having to backspace and then stop for a good 30 seconds trying to figure out how to write the file and get out of the dang thing.

but yeh, to other people i guess it's "easy" :P


"I'm so 1337, GNU Nano gives me a panic attack"—You, 2017


I guess it depends on where you come from; see to me Nano is easy and natural because I grew up telnetting into a Unix system and using Pine/Pico. It was the status quo, it was just the way things were and we learnt it and got on with our day to day lives, we sure as hell didn't have a choice what editor we got to use on that box.


File: 1492568851415.gif (1.93 MB, 480x360, NO MORE.gif)

yeh, just being silly. though its bindings don't really match up with anything else used these days, nano definitely does its job as a "universal interface" in that anybody can figure out how to use it on the spot, what with the help bar being auto-displayed.

>tfw doctor-certified panic disorder and everything is terrifying always


I use i3 on my laptop and awesome on my desktop and they're both solid wms, the main difference in every day use is how the windows are tiled; i3 is done manually so you have much more control but awesome has pre-set patterns which are easier to switch. The i3 config is easy but you can do more with awesome.


Switched back to i3 after that recent awesome update that broke backwards compatibility with the API.
It's not as extendable or customizable but it is considerably less time-consuming to configure.




>some data: package sizes for arch x86
i3-wm 894Kb
awesome 8.3Mb
emacs 103Mb
nano 2.2Mb

the size differences here are a bit curious, i3 is smaller than awesome, but it isnt by the same degree as nano to emacs by a long shot.

I feel like a lot of the difference between i3 and awesome isnt so much that i3 lacks features awesome has, its just that awesome makes them accessible-er, wheras i3 covers them up with a more basic config. essentially, somewhere inside of i3 you have an equivalent to that four line keybind, its just a little harder to poke at than in awesome.

still there is some difference in size, and a factor of ten isnt to be ignored, but if i3 needs a few more packages (bar+lock+dmenu| who are prebuilt in at awesome (where if I recal correctly some images are packed by default, inflating the size a fair bit id figure), the sizes between them might be negligable.


statically linked dwm 67K
dynamically linked(like your packages) 53K
(do note I am using Musl)

At the end of the day there is a simple elegance about dwm. It does exactly what a window manager should do. It doesn't get in your way, it doesn't give you a bloated cryptic config format, it displays windows.
If its default installation doesn't offer you everything you need it is written in clean C and is easily extended by hacking around in the source.
I personally can't stand any of these other window managers which draw disgusting bars around your windows, or do other such useless nonsense. The WM should stay out of my and be virtually unnoticeable when I use it, and that is exactly what dwm offers.


I use wm_utils, UNIX phylosophy all the way



err, pardon me but I am struggling a bit to see how these posts relate to the op; this is not a ''brag about your elegant, stylish, philosophically correct, beautiful, snazzy, adorably hugable wm / desktop arrangement''-thread, this is a thread that was for a bit it looked like actually trying to talk about wms and editor analogies in a way that was not reduced quickly to a MINEISABEST shoutfest.

can we like, get back on track folks? thanks~~


do you also think SSL is bloat?


Then remove the bar at the top, and remove tiling. Then the window manager will be actually usable.


I'm getting bored of i3 and I was thinking of maybe moving to awesome.
Thanks for saving me the trouble.
What are some other tiling window managers I should try, besides dwm and the overly complicated and bloated ones like Awesome?


personally I like ratpoison.

it takes a little getting used to, and a little configuring, and maybe a little bit of a different keybinding manager, but its nice.


Came here to post this. Even if my cofiguration is still barebones it feels extremely functional and I managed to make something that is in between a full tiling and just a floating one. Also I can change whatever I want by just making new bash scripts instead of having to dive in a full program like dwm or ratpoison.
I find a bit hard and inane to describe wm by comparing them to text editors. They are used for different purposes, and there are much more different philosophies for wms than for text editors. Can we just talk abot wm as wm?

[Return] [Go to top] [ Catalog ] [Post a Reply]
Delete Post [ ]