# sxwm: a dynamic tiling window manager in three C files

> sxwm is a small X11 tiling window manager written in C, with a configuration file that carries every feature and option, and a Makefile that builds it with a single command. The README is short because the real documentation is the default configuration file, and the author warns that nobody maintains the packages, so the third-party builds are at your own risk.

**uint23/sxwm** — a simple feature-rich dynamic tiling window manager

- Repository: https://github.com/uint23/sxwm
- Stars: 1,041 · Forks: 60
- Language: C
- License: GPL-3.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/uint23-sxwm

## Three source files, and a configuration that carries the weight

sxwm is described as a simple feature-rich dynamic tiling window manager, and the source tree is small enough to read in an afternoon. There are three C files, sxwm.c, parser.c and utils.c, with three headers, common.h, parser.h and utils.h, and a patches/ directory.

The README's first line points at the real documentation, default_sxwmrc, and says it contains a complete list of features and configuration options. That is a deliberate choice and it is how this family of window managers works. The configuration file is not a settings file that a program reads and ignores, it is the source of the behaviour, and in a well-built one it is meant to be edited like code, with a rule per line and a comment above each one.

The Makefile shows the shape of the project as clearly as the source listing does. The compile is three files with a strict flag set, -std=c99 -pedantic -Wall -Wextra -O2, and the defines -D_DEFAULT_SOURCE and -D_XOPEN_SOURCE=700, which are the feature test macros needed to reach the POSIX interfaces the code uses. The output is a single binary called sxwm, and the install target puts the binary in the prefix bin directory and the default configuration in share/sxwmrc, so the two are installed together and the configuration is yours to edit.

The vocabulary in the project is the dwm vocabulary. Dynamic tiling means windows are arranged and rearranged automatically as they open and close, and the configuration is the set of rules that decide how.

## X11, and the warning about packages nobody maintains

The build section opens with a warning, and it is the most quotable line in the README: I don't maintain any packages. Use third-party packages at your own risk.

That is a maintainer being direct about the state of a distribution ecosystem, and it is a warning an installer should read. The Arch and Void packages listed in the README are community packages, which is the normal arrangement for a small C project, but the author is pointing out that the AUR package and the Void package are not artefacts he reviews.

The dependencies are minimal, which is the other thing the build section establishes. Xlib is the base X11 client library. Xinerama is the extension for handling multiple screens, so a multi-monitor setup works. XCursor is the cursor rendering extension, without which the pointer looks wrong under a tiling manager. And you need a C compiler, invoked as CC, plus Make.

That is a short list compared with a compositor-based stack, and it is the reason the project builds from source in a couple of seconds. It is also the reason there is a separate document, docs/SPECIFIC_BUILD.md, for distribution-specific build dependencies, because the library names differ between distributions and a build guide for each would be noise in the main file.

## Building and installing with make

The build from source is three commands:

```sh
git clone https://github.com/uint23/sxwm
cd sxwm/
make
```

and then, if you want the binary and the default configuration in the system prefix, which is /usr/local by default:

```sh
sudo make install
```

The Makefile makes the separation clear. The all target compiles the three sources and links against -lX11 -lXinerama -lXcursor, and the install target creates the bin directory, copies the binary with mode 755, and copies default_sxwmrc to share/sxwmrc. There is an uninstall target that removes both, and a compile_flags target that writes the flags to a compile_flags.txt file, which is a convenience for editors and for static analysis tools that read the build flags from a file.

Two details in the Makefile are worth knowing before you hit a build error. The include path is hard-coded to /usr/X11R6/include, and on a distribution with the headers somewhere else you either adjust that or read the build dependencies guide, which is what the README points you to. And the linker search path is /usr/X11R6/lib, with the same consequence.

The pre-built packages avoid those questions entirely, and the README lists them for Arch Linux with yay -S sxwm, and for Void Linux with sudo xbps-install -S sxwm, which is the shorter path if you are on one of those two.

## Starting it, and the session file that comes for free

Running sxwm is described in two ways. The first is to start it with startx, which means adding a line to your ~/.xinitrc:

```sh
exec sxwm
```

The second is to select sxwm from your display manager's session menu, and the README notes that the sxwm.desktop session file is installed automatically. That detail is a small kindness, because a display manager session entry is the kind of thing that is normally a manual step.

The exec in the xinitrc matters for a practical reason. A window manager has to be the session's process, and exec replaces the shell with it, so that closing the window manager ends the session rather than dropping you at a prompt with no display server behind it. Getting that wrong produces a confusing black screen rather than an error message.

It is also worth noting what the README does not say. There is no mention of a status bar, no keybinding system beyond whatever the configuration defines, and no session management beyond the session file. The description says simple and feature-rich, and the feature list is in the configuration, which is the honest way to present a project whose surface area is a file you edit.

## Where sxwm is the wrong choice

The first wrong-tool case is a Wayland session. The dependency list is Xlib, Xinerama and XCursor, and the project is built as an X11 client. A user on a modern GNOME or KDE Plasma session, where Wayland is the default and XWayland is a compatibility layer rather than the native path, is not going to get the experience the project is designed for.

The second is a user who wants a modern, batteries-included desktop. This is a window manager, not a desktop environment. It manages windows, and it expects the rest of the session, the panel, the launcher, the notification daemon, to come from somewhere else. Somebody moving from a full desktop has to assemble those parts themselves, which is the trade every tiling window manager makes and the one sxwm makes most explicitly.

The third is a user who wants to configure through a GUI. Everything here is a text file. That is an advantage for a keyboard-driven user and a barrier for anyone else, and the README does not pretend otherwise.

There is also the packaging risk stated plainly. A community-maintained AUR or Void package for a small C project is normally fine, but the author explicitly declines to maintain packages and says to use them at your own risk, and the version in a package may lag the release. Building from source takes a few seconds and gives you the exact commit you want.

## The dwm lineage, and a project that keeps shipping

The thanks section names the projects that shaped sxwm, and reading it is a good map of the design space. dwm is credited for the tiling and for the source code, and the code structure follows it. i3 is credited for easy configuration. sowm is credited for README inspiration. And tinywm is credited as a minimal X11 window manager.

So sxwm sits in a specific lineage. It is a dwm-derived tiling manager, it borrows i3's attitude towards configuration files, and it is written in the same small-footprint C style, with the whole program in a handful of files and a Makefile that compiles it in one command.

The release history shows a project that keeps shipping. The versions are v1.8 from 2026-10-11, v1.7 from 2025-10-13 and v1.6 from 2025-06-26, so a release roughly every year, and the last push was on 2026-10-13, two days after the 1.8 tag. The default branch is master, and the project is licensed under GPL-3.0 with the LICENSE file at the root.

For a window manager, the interesting number is not the feature count but the size of the code, because that is what makes it auditable and what makes it reasonable to trust on a machine where you type your passwords.

## Conclusion

Adopt sxwm if you want a dwm-style tiling window manager in C that you configure in a single file, and read default_sxwmrc before you install anything, because that file is where the behaviour lives. Do not adopt it if you want a Wayland session, since the dependency list is X11, Xinerama and XCursor, and do not rely on a distribution package without reading the warning about who maintains them. Before you build, check the X11 headers on your system, since the Makefile points at /usr/X11R6/include, and read docs/SPECIFIC_BUILD.md for the dependencies your distribution names differently.

## FAQ

### What is sxwm and how is it configured?

It is a simple feature-rich dynamic tiling window manager for X11, written in C. The configuration is a single file, default_sxwmrc, which the README describes as containing a complete list of features and configuration options, and it is installed to the share directory and edited like code.

### How do I build sxwm from source?

Clone the repository, change into the sxwm directory and run make, then sudo make install to place the binary in the prefix bin directory and default_sxwmrc in the share directory. The dependencies are Xlib, Xinerama, XCursor, a C compiler and Make, and docs/SPECIFIC_BUILD.md covers distribution-specific packages.

### How do I start sxwm with startx?

Add exec sxwm to your ~/.xinitrc, or select sxwm from your display manager's session menu, since the sxwm.desktop session file is installed automatically. The exec form is the usual one because the window manager has to replace the shell as the session process.

### Are the sxwm packages safe to use?

The README carries a warning that the author does not maintain any packages and that third-party packages should be used at your own risk. Arch Linux and Void Linux packages are listed, and the source build is a few commands.

### What licence is sxwm released under?

GPL-3.0, with the LICENSE file at the repository root. The most recent release is v1.8, dated 2026-10-11, after v1.7 in October 2025 and v1.6 in June 2025, and the last push was on 2026-10-13.

## Sources

- [Issues](https://github.com/uint23/sxwm/issues)
- [License: GPL-3.0](https://github.com/uint23/sxwm/blob/master/LICENSE)
- [README](https://github.com/uint23/sxwm/blob/master/README.md)
- [Releases](https://github.com/uint23/sxwm/releases)
- [uint23/sxwm on GitHub](https://github.com/uint23/sxwm)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/uint23-sxwm