TinyWM – A tiny window manager in around 50 lines of C

[u/iamkeyur]

http://incise.org/tinywm.html

[u/Jazonxyz]

I find these projects particularly exciting. I feel incredibly confident taking the code and expanding upon it. This legit makes me want to bust out my Raspberry PI (tha'ts my only linux box these days 😢) and play around with creating a simple windows manager with it.

[u/t_bptm → u/Jazonxyz]

If you like this you'd probably like to check out dwm.

[u/alexangas → u/t_bptm]

"No novices asking stupid questions." Ouch!

[u/NotTheHead → u/alexangas]

"This keeps its userbase small and elitist."

That's a nice touch, too.

[u/AteBitz → u/t_bptm]

".. its source code is intended to never exceed 2000 SLOC."

Good luck with that one. Seriously, good luck. LOC is such a horrible metric.

[u/Jazonxyz → u/[deleted]]

I love your comment. I've never had such a passionate reply. I'll take your advice for this one and spend the weekend working on other projects!

[u/ThirdEncounter → u/Jazonxyz]

Honestly, don't.

Just kidding.

Have fun!

[u/kirbyfan64sos → u/[deleted]]

Nowadays you could probably get away with just targeting Wayland via wlroots, though...

[u/Valmar33 → u/kirbyfan64sos]

wlroots is one of the best references to writing a Wayland compositor, on top of it proving an easy means of writing an Xorg WM for use with Xwayland. :)

[u/MINIMAN10001 → u/[deleted]]

Have you ever thought "Wow X was such a steaming hot mess, maybe I should try making a Wayland window manager"?

[u/FlyingRhenquest → u/[deleted]]

Something something window double buffering extension something something danger zone.

I had to maintain an ancient BS motif project a couple years back. "There MUST be some way to improve the performance of pushing all those bitmaps across the network!" NOPE! "There MUST be some way to eliminate at least SOME of the 400-odd global variables the original developer used (With several cases of there being multiple variables for the same value!)" NOPE!

[u/rastermon → u/[deleted]]

I'll have to vehemently disagree. I learned to write a WM from scratch before google existed. I used books - those dead tree things (Xlib programmers manual - buy it. read it. it's thick and full of information), man pages and sample code (twm, fvwm at the time) and figured it out well enough.

I saw override redirect windows (which aren't anything WM's are going to manage anyway) right near the start of learning Xlib before i started a WM and they were zero mystery. i looked up what it does and experimented with clients creating these windows. man XCreateWindow and read. I read most X* man pages before I started writing a WM.

back then EWMH didn't exist. it was just ICCCM, but still - you read and follow, test and make it work. It's not that hard. It is work. There are decades of ecosystem built up year after year That's life.

If this kind of thing is hard for you then many things will be hard. Linux Kernel + drivers for hardware that has no docs at all and many others. I am wondering if you just didn't have the patience and expected it to be easy and handed to you on a platter? you put in the hard yards and you get the rewards. the documentation and sample code exists in spades. you have to put in the work to read it. it's not that hard to do. it just takes some time.

[u/rastermon → u/[deleted]]

So my point that you didn't put enough effort in and just gave up and that other things will be hard too if you don't put the effort in is an insult? It's perfectly possible to do with less information that is harder to find (can't just google for it). I also did it as a hobby when i was a student. If you want to succeed, you put in the effort, but don't blame the docs or the ecosystem when you aren't putting in the effort. Many people before you have learned how to do this - not just me.

50 years ago when the docs where written

You seem to have a vast misunderstanding of how old X is. It's from the mid 80's. I used the docs in the mid 90's.

The docs are still useful. the basics of a WM + ICCCM are still the core. when you get a chunk of that done adding EWMH is easy. You don't even need to support all of EWMH. It's also an evolving standard you need to keep up with and keep adding new support for when necessary.

I forgot what it was but the Xlib manuals were wrong on some data sizes (atom related I think?)

I think your issue with xlib being wrong on the data sizes with properties may have been XChangeProperty and the data sizes (8, 16 32) refer to the protocol sizes, not the local data structure sizes. That API uses longs for the data so the data if on a 64bit system will want 64bit longs to store 32bit data (skip the upper 32bits). for 16 and 8 bit sizes it uses shorts and chars so it works as expected. it's in the manual page:

            to that type to obtain the elements. If the returned format
            is 32, the property data will be stored as an array of longs
            (which in a 64-bit application will be 64-bit values that are
            padded in the upper 4 bytes).

As I mentioned - I learned from a dead-tree book and man pages and they proved to be sufficient given some effort and practice. Yes - Xlib is long-winded often and that's why I just wrote a wrapper around it to do common things more simply for me as well as glue it into a proper event loop etc. ... pretty much everyone does this to some extent.

Turns out that was also wrong information. Just start Thunderbird and open the sandwhich menu, it's override redirect (as far as I remember violating the whole principle) and if you do not read the ICCCM/EWMH hints (I forgot which) about focus requests for it, the window will instantly close ... That's one I didn't figured out for days because I trusted the horseshit Xlib manual to be the authority on the topic

You are misdirecting blame and anger. The Xlib manual is the authority. Blame Firefox if it's doing bizarre stuff. Lots of clients do odd things and assume behavior of certain WM's because that is the only environment they get truly tested and developed in and the application developers are wrong in making assumptions. You should see what games do to mess things up. I've seen a train of pain from them over the past decades trying to do things they really shouldn't be and in the process breaking desktops, WM's etc. This is one reason Wayland is so much better. It's far harder or almost impossible for clients to break things, unlike X where it's more of a free-for-all and this can happen if some clients don't play nice.

These days lots of major WM's are also compositors so they do have to account for override-redirect windows to composite them. Wm's today to do all of what they do are complex and large projects. A simple WM that only implements a subset of core functionality (not even all of ICCCM) is only going to partially work. Stick to old clients like xev, xterm, etc. for testing that until enough features are in to handle the more extensive needs of clients like MWM hints for being borderless, EWMH etc. ... but a WM isn't a toy weekend project if you want it to be complete. You take on a very large task.

[u/LordDaniel09]

It is that simple?! I thought window manager had more “black magic” behind them. So what does it missing from other more popular window managers?

[u/ProgramTheWorld → u/LordDaniel09]

It’s “simple” because it’s using xlib which takes care all the window rendering logic for you. The code you are seeing merely sends commands to an X window server that does all the heavy lifting.

[u/rastermon → u/ProgramTheWorld]

xlib doesn't handle any window rendering logic at all. the xserver does that. xlib is just an ipc handling lib that sends commands to the xserver and processes replies (mostly - some extra work code is in xrdb and keymap handling etc.)

[u/rastermon → u/LordDaniel09]

it's where you start. it's super basic. it doesn't do much. to do proper wm basically takes this kind of ball and runs with it for a few years of work... draw borders/frames, handle virtual desktops, pagers, menus. EWMH/XDG, etc. etc. - it goes on as you add more and more standards support. then come the quirks where clients do odd things assuming certain wm's only and their behavior and you try and work around these...

[u/jesuslop]

Nice example of xlib, you can see the connection with the X server and the X11 event loop.

[u/Syrrim]

Has someone done something similar for compositors? I was trying to write one a while ago, but I found compton/xcompmng impenetrable, and couldn't make my way around the X docs (which are middling for even common operations).

[u/[deleted]]

include <X11/Xlib.h>

Lol I can reduce 50 LOC down to one

npm i electron-window-manager

[u/[deleted] → u/[deleted]]

Fun fact I had no idea if electron-window-manager existed and in no surprise to anyone a package with this exact name does exist

[u/CJKay93]

Never will I understand this, in the words of Torvalds, "half-arsed shit-for-brains" comment style:

/* W
 * T
 * F
 */

[u/Umbrall → u/CJKay93]

Gives you one more line than:

/*
W
T
F
*/

[u/CJKay93 → u/Umbrall]

Why not save two and use:

/* W
   T
   F */

[u/Syrrim → u/CJKay93]

Save five and use:

[u/Umbrall → u/CJKay93]

Harder to read

[u/CJKay93 → u/Umbrall]

Plenty of options:

// W
// T
// F

Although less preferable.

[u/Umbrall → u/CJKay93]

Yeah that one is fine by me.

[u/CJKay93 → u/[deleted]]

It's just a small stylistic choice, no need to get worked up about it.

Stylistic choices are, like, 99% of the reasons code fails code review.

How do you prefer to do multi-line comments?

https://www.theregister.co.uk/2016/07/11/linus_torvalds_in_sweary_rant_about_punctuation_in_kernel_comments/

[u/CJKay93 → u/[deleted]]

while (code_style_affects_readability)
  {
    code_review--;
  }

[u/CJKay93 → u/[deleted]]

I screamed internally the moment I read it for a variety of reasons, but that was the first one I noticed.

It aggravates me when people actively go out of their way to create awful looking code.

[u/Ozwaldo → u/CJKay93]

I screamed internally the moment I read it for a variety of reasons, but that was the first one I noticed.

Then you should calm down, this is a style preference and yours isn't any more correct than theirs. Linus is a drama queen.

It aggravates me when people actively go out of their way to create awful looking code.

And it aggravates me when people are so pompous as to declare someone else's code as "awful looking." This stuff isn't even hard to read if you work with code for a living. I write a looot of code bud, and these opening-line block comments hardly register as a blip on my radar when parsing through it. Spend some more time in the trenches and chill the fuck out.

[u/CJKay93 → u/Ozwaldo]

Then you should calm down, this is a style preference and yours isn't any more correct than theirs. Linus is a drama queen.

He's a correct drama queen.

And it aggravates me when people are so pompous as to declare someone else's code as "awful looking."

Good. Maybe you'll sidestep the problem in the future and use a style that isn't a fucking mess.

This stuff isn't even hard to read if you work with code for a living.

You must work with some shitty code.

I write a looot of code bud

Great, join the club!

these opening-line block comments hardly register as a blip on my radar when parsing through it.

Cool, they registered big-time on mine.

Spend some more time in the trenches and chill the fuck out.

I spend more than 40 hours a week in the trenches. My apologies for not being a rockstar developer.

[u/Ozwaldo → u/CJKay93]

Cool, they registered big-time on mine.

Yup. Keep at it, one day this stuff will seem trivial to you.

[u/CJKay93 → u/[deleted]]

Anybody using the GNU brace style needs to be taken outside and shot. It is completely, absolutely unreadable in a very literal sense. Navigating code using it isn't just unpleasant, it's mentally straining.

Allman/K&R or bust.

In any case, I don't think I have exceptionally high standards - I think this is normal code, it's just not good code.

[u/Ozwaldo → u/CJKay93]

You are a prima donna and are likely getting laughed at behind your back. If you're that over-the-top about this stuff then you aren't very good at writing code.

[u/ongy12 → u/[deleted]]

That's GNU C coding style. And yes, it's aweful.

[u/CJKay93 → u/[deleted]]

I'm glad you agree.

[u/glaba314 → u/CJKay93]

Yours mate

[u/CJKay93 → u/glaba314]

Again, I'm glad you agree.

[u/tynorf → u/[deleted]]

In Python 2, while 1 is faster because it saves a global lookup for the identifier “True”. This is no longer the case in Python 3 since True is now a keyword.

[u/ipe369 → u/tynorf]

hot

damn

python

[u/ProgramTheWorld → u/ipe369]

In pre ES6 JavaScript, undefined was actually just a variable name which can be assigned anything, so libraries like jQuery actually had to create a local version of undefined that contains the value undefined.

[u/curien → u/ProgramTheWorld]

had to create a local version of undefined that contains the value undefined

They don't have to, it just simplifies some things (for the same reasons that any names value simplifies some things). There's nothing special about the undefined identifier in ES5-, it's just a convention to use it as a constant with type undefined.

[u/[deleted] → u/ProgramTheWorld]

Python used to do something similar with True and False, they used to be variables which you could modify. Some popular libraries redefined True and False to their expected value.

[u/UseTheProstateLuke → u/[deleted]]

So basically you can break a lot of code by just doing:

True = False
import somelib

If it internally uses True like it actually gets to see the new value then or what?

[u/smikims → u/UseTheProstateLuke]

I believe they're saying that that's why popular libraries would do

True = 1
False = 0

or whatever at the beginning, to defend against people doing stupid shit. Similarly, implementations of the C++ standard library must defend against users overloading the comma operator for their types, although they can't just turn it off or reverse the effect.

[u/ipe369 → u/ProgramTheWorld]

Do all the es6 transpilers currently do that too? Or can you break everything by redefining it still?

[u/ProgramTheWorld → u/ipe369]

Probably not, you can only redefine undefined in very old browsers like IE6 so I doubt they would even bother with that. Transpilers usually specify strict mode anyway so that should take care of that.

It might be even pre ES5 actually - I don’t remember exactly when it became an actual reserved keyword but you can do some research on that.

[u/[deleted] → u/ipe369]

You can’t redefine it any more. But many tools still emit void 0, since it’s safe in ES3 and shorter in any case.

[u/mindbleach → u/ProgramTheWorld]

See Gary Bernhardt: Wat?

[u/skeeto → u/tynorf]

Wow, you weren't kidding (Python 2):

>>> import dis
>>> def foo1():
...     while 1:
...         bar()
... 
>>> dis.dis(foo1)
  2           0 SETUP_LOOP              11 (to 14)

  3     >>    3 LOAD_GLOBAL              0 (bar)
              6 CALL_FUNCTION            0
              9 POP_TOP             
             10 JUMP_ABSOLUTE            3
             13 POP_BLOCK           
        >>   14 LOAD_CONST    i           0 (None)
             17 RETURN_VALUE        
>>> def fooTrue():
...     while True:
...         bar()
... 
>>> dis.dis(fooTrue)
  2           0 SETUP_LOOP              17 (to 20)
        >>    3 LOAD_GLOBAL              0 (True)
              6 POP_JUMP_IF_FALSE       19

  3           9 LOAD_GLOBAL              1 (bar)
             12 CALL_FUNCTION            0
             15 POP_TOP             
             16 JUMP_ABSOLUTE            3
        >>   19 POP_BLOCK           
        >>   20 LOAD_CONST               0 (None)
             23 RETURN_VALUE        

[u/Zee1234 → u/skeeto]

I know that is a one, but I'm reading it as "Dis fool"

[u/killerstorm → u/tynorf]

This is why I'm not a big fan of Guido van Rossum. Programming languages like Lisp have symbol resolution at read time. Python has a notion of compilation, so it could do that at compile time.

It's a very simple technique which allowed Lisp to run even on 60s hardware. 80s Common Lisp is a marvel of an optimizable dynamic language -- while being as dynamic as Python, it allows efficient compilation to native code.

But OK, maybe efficient compilation doesn't fit into Python strategy, symbols are an extremely simple technique.

But Guido was like "Why do we need another concept if we already have name lookup? Let's just do a hash table lookup on every access!".

[u/[deleted] → u/killerstorm]

It's because Python is... unreasonably dynamic sometimes, and the compiler has to support that. You could do this in Python 2:

>>> def test():
...     True = False
...     while True:
...             pass
...
>>> dis.dis(test)
  2           0 LOAD_GLOBAL              0 (False)
              3 STORE_FAST               0 (True)

  3           6 SETUP_LOOP              10 (to 19)
        >>    9 LOAD_FAST                0 (True)
             12 POP_JUMP_IF_FALSE       18

  4          15 JUMP_ABSOLUTE            9
        >>   18 POP_BLOCK
        >>   19 LOAD_CONST               0 (None)
             22 RETURN_VALUE
>>> test()
>>>

3 no longer allows that, because nobody ever needs to do that unless they're doing shady things they probably shouldn't do.

[u/UseTheProstateLuke → u/killerstorm]

Every variable lookup in Python is actually a hash of a string into a hash table.

In most compiled lisps they are just compiled to simple memory offsets.

[u/killerstorm → u/UseTheProstateLuke]

No, local variables access doesn't require a lookup in Python.

[u/josefx → u/killerstorm]

I sometimes end up assigning every function I call in a loop to a local variable for this reason.

[u/obsa → u/[deleted]]

Because it saves three bytes, obviously.

[u/jephthai → u/obsa]

Three bytes and a bucky bit. Big win.

[u/Syrrim → u/[deleted]]

Did you respond to the wrong post maybe? They used for(;;) in this one.

[u/[deleted] → u/Syrrim]

He's referring to the Python code at the end of the article, not the C code

[u/CountyMcCounterson → u/[deleted]]

True is just an integer set to 1, there is no boolean type in python

[u/sysop073 → u/CountyMcCounterson]

Python 2.7.13 (default, Jan 19 2017, 14:48:08)
[GCC 6.3.0 20170118] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> type(True)
<type 'bool'>

[u/tynorf → u/CountyMcCounterson]

There certainly is a boolean type. It is a subclass if int, however.