Enables the protocol documented at
https://wayland.app/protocols/ext-data-control-v1
It is the upstreamed version of the old wlr_data_control.
It is used e.g. by mpv to read and write the clipboard.
Currently when a rule that doesn't make windows floating matches, even
sub-windows of float type get tiled rather than just the main window.
This is inconsistent with dwm and other compositors. Fix this by making
these windows floating after applying rules.
Fixes#1142.
This reverts commit 33bcd2e4ca.
We keep LISTEN_STATIC for three instances where we use it. We use
simple listeners for the rest of signals.
This is the continuation of 0925fe956a
Recently wlroots was updated to assert that signals do not have listeners
attached on destroy.
This is just a preliminar work to fix dwl. At the moment dwl will trigger the
assertions at exit.
References: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/4918
By placing the default WLR_INCS and WLR_LIBS before the ones for an
alternative wlroots, they don't need to be commented to enable the
alternative ones.
The hyphen-minus <-> and apostrophe-quote <'> are interpreted by troff
as hyphen and right single quotation mark. See groff_char(7).
Fixes: 0db6f3c5b5 ("add dwl(1)")
Applybounds doesn't move client when it overlays
only with border with monitor to the right.
Apparently, c->geom.width already includes the border
as well.
Previously we didn't take into account their borders requiring us to add
`borderpx` to override_redirect clients.
Fixes: https://codeberg.org/dwl/dwl/issues/651
This patch is based on the original stale patch by Guido Cella @guidocella.
It has been modified to apply cleanly to the latest v5.0 tag. Since the SLOC
limit is now lifted, this core feature should be merged into dwl upstream.
Thanks to Dima Krasner @dimkr for the cherry-pick.
Closes: #559, #525
When a user's startup_cmd is a little more complex, e.g. a shell script,
and forks off several processes, then killing only the main child pid
might leave unwanted processes behind on exit. Not all children will
notice when their parent or the compositor has quit.
To fix this, put startup_cmd into its own session and process group, and
kill the entire group on exit.
bemenu is very bloated, turning itself into a library, which makes it
7489 SLOC.
wmenu on the other hand, looks suckless by default, and is only 2000
SLOC, which i also find alot nicer to use, since bemenu does nothing
to replicate the original dmenu feel.
Make example rules be actual EXAMPLES.
Now newcomers should not have to ask, "When I start firefox, nothing
happens. What is going on?"
Also clarified a minor typo and a consistency in spacing.
When motionabsolute() is called from warpd, event->time_msec is 0, so
motionnotify() doesn't call wlr_cursor_move(). Fix this by explicitly
warping the cursor in this case, like it was done before implementing
pointer constraints.
I don't know if this is a bug in warpd or time_msec is always 0 with
virtual pointers, since the only other software that uses the virtual
pointer protocol I know of is wl-kbptr, and I can't get that to work
with dwl at all.
When a child window of a fullscreen client is mapped, the fullscreen is
disabled, and if the previously fullscreen client is floating the child
window is rendered below it and cannot be seen, causing confusion,
though it is still focused and interactable.
Fix this by putting children of fullscreen clients in LyrFS instead of
LyrFloat, and by returning before the unset_fullscreen code is called
when they are mapped.
focusstack() now lets you switch focus from a fullscreen client to its
child windows, otherwise if you switch focus from the child window to
the fullscreen client you could not focus the child window again and the
fullscreen client would stay unresponsive.
Child clients are not reparented to LyrFloat after leaving fullscreen,
so you could spawn a child window, focus back the fullscreen client,
unfullscreen it, and the child window would still be drawn above other
floating clients. Avoid dealing with this edge case to keep the line
count low.
These cases can be tested by pressing Ctrl+o in applications with an
open file dialog.
Revert 3213088 because the linked bug can no longer be reproduced with
wlroots 0.17, and update client_get_parent() so it doesn't segfault with
XWayland surfaces. This also allows reusing the p variable in the next
commit.
These don't do anything because wlr_scene_node_reparent() is immediately
called again by setfloating() through setmon(). They are also a source
of confusion because if you change the wlr_scene_node_reparent() call in
applyrules() it takes a while to understand why it doesn't work.
For wine clients often configurex11() is called before mapnotify() and
therefore c->mon is NULL. configurex11 just returns early in that case,
letting these clients stay in the wrong size. For example only the top
left part of winecfg and wine uninstaller is drawn, or confirmation
dialogs like when closing wine notepad are too big. Fix this by
configuring their surfaces like before 88d386b.
The compositor must respond to the client requesting a change to the decoration
mode, it does not matter if the compositor chooses a different mode.
This reverts commit 9071ce6c84.
previously it worked because we checked in every commit the layer
in a353eee2ca and
b100b446b8
we changed the way it's handled and now if the layer surface does not change
the layer we don't it either. meaning that if it was created in the bottom
layer and did not change the layer the popups would show behind xdg clients
Passing NULL to wlr_keyboard_set_keymap results in a segfault.
Example:
Thread 1 "dwl" received signal SIGSEGV, Segmentation fault.
0x00007ffff7e49b64 in xkb_keymap_ref () from /usr/lib/libxkbcommon.so.0
(gdb) bt
#0 0x00007ffff7e49b64 in xkb_keymap_ref () at /usr/lib/libxkbcommon.so.0
#1 0x00007ffff7f06389 in wlr_keyboard_set_keymap () at /usr/lib/libwlroots.so.11
#2 0x000055555555bc54 in createkeyboard ()
#3 0x000055555555c283 in inputdevice ()
#4 0x00007ffff7e8101e in wl_signal_emit_mutable () at /usr/lib/libwayland-server.so.0
#5 0x00007ffff7e8101e in wl_signal_emit_mutable () at /usr/lib/libwayland-server.so.0
#6 0x00007ffff7edb52c in () at /usr/lib/libwlroots.so.11
#7 0x00007ffff7ee44b6 in () at /usr/lib/libwlroots.so.11
#8 0x000055555555fe66 in main ()
the artifacts were caused because we tried to set the gamma right after
receiving the event, this resulted in two pending page-flips, which
not always play well together.
This also seems to fix a screen freeze when turning on a monitor that has
gamma.
Additionally the current method won't work once [0] is merged
[0]: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/4423
Note that previous df131cdb78 libX11 headers
were also required for building (but not for runtime)
Also, I want to apologize to the packagers for do not list *all* the required
dependencies before.
For some reason brave configured for as a wayland client triggers this code on startup and segfaults.
Checking if the client is mapped fixes this, like with the previous fix for urgent border colour.
References: 887fde65a3
Fixes: 72a7d78a1a
Use an early return to avoid indenting the main logic instead of
wrapping the tail of a function in an if statement.
No functional change, except for a handful of places where printstatus()
was being called spuriously (tag, toggletag, toggleview).
ΔSLOC: 0
The scene graph implementation sends these for us, and it does so more
accurately than our overly-simplified approach. Layer shell surfaces
don't appear to receive these events at all, according to my
WAYLAND_DEBUG experiments with bemenu and dtao.
ΔSLOC: -4
If there is no current drag icon, this node will be empty, but we now
have `drag_icon != NULL` as an invariant. This allows us to eliminate a
conditional, since there's no harm in moving an empty node's coordinates
around with the pointer.
ΔSLOC: -1
This parallels the LISTEN macro for statically allocated listeners, and
it allows us to remove almost all of the global wl_listener
declarations.
This also fixes a bug with the axisnotify listener, which was declared
with a compound literal. At block scope, these have automatic storage
duration [1], so the listener was no longer valid after setup()
returned. (The option to declare it static explicitly was standardized
in C23, if that ever gains suckless traction.)
ΔSLOC: -27
[1]: https://en.cppreference.com/w/c/language/compound_literal#Explanation
If we treat the drag icon as distinct from other layers (it doesn't have
contents that are interactive, focusable, etc.), then we can iterate
over layers meaningfully with a simple for loop.
ΔSLOC: -8
while the size of `int` in most compilers is 32-bits, the size of int and all
other integer types are implementation defined, so make sure we can use up to
32-bits
- Replicate missing functionality from dwl to display the client count in monocle mode
- Add ltsymbol field to Monitor struct
- Display client count in monocle mode when greater than zero
- Tested with somebar and dwlb
selclient() does not work well when dealing newly mapped
clients (specifically those mapped on invisible tags).
This fixes various bugs related to things not working because selclient() would
return NULL.
References: 94c8bd6048
this also changes our policy about when we unset fullscreen:
dwl will unset fullscreen for clients who share tags (and monitor) with a newly
mapped client, it does not matter if the clients are visible or not
checking `bypass_surface_visibility` first, could cause that even if the idle
inhibitor is being destroyed it will disable idle tracking
and if we couldn't get its scene tree, then assume that the surface is visible
This reverts commit 035bb99d67.
Not checking `tree != NULL` result in a segfault if the surface doesn't have a
role (for example because it is a newly created surface)
Closes: https://github.com/djpohly/dwl/issues/359
When c->bw is 0, the right side of the MAX functions gets turned into an unsigned integer and that results in -1 being the outcome.
This causes big issues in xwayland clients.
this fixes another issue where the cursor doesn't change when selecting text
but there is still an issue about not changing border color of clients during
dnd operations
Bug: https://github.com/djpohly/dwl/issues/318
- allow user to use a different pkg-config binary
- restore almost all (and add other ones) warning flags (-Werror is not set)
- $(XWAYLAND) is added to our CPPFLAGS
- remove useless comments
- don't generate idle-protocol.h (not used)
it is closer to the suckless philosophy (foot implements things that the suckless
guys would say that should be done by tmux or something else, but I have no
desire to create a new terminal emulator, and the best fit is foot)
also alacritty uses +100Mb of memory, more that dwl itself (~90Mb)
and foot only ~20Mb
when using wlr_output_layout_move() wlroots internally
change the state of the output to manually configured and
when updating the layout these outputs aren't ignored by
wlroots, leaving us at our own
previously we tried to get a client from the surface and then compare it with
the excluded surface, if we cannot get a client from the surface (e.g: a layer
surface) it just ignored all the next idle inhibitors no matter what
What I have should done is just checking if the excluded surface is equal to
the current idle inhibitor's surface and continue in case it is.
this will help when sending to another monitor a fullscreen client
and also will prevent a crash when a client request fullscreen when it has no monitor
When the dwl executable is in use, cp fails without the -f flag.
POSIX defines this flag with:
> If a file descriptor for a destination file cannot be obtained,
> as described in step 3.a.ii., attempt to unlink the destination
> file and proceed.
dwl.c: In function ‘unmaplayersurface’:
dwl.c:2253:9: error: suggest parentheses around assignment used as truth value [-Werror=parentheses]
2253 | layersurface->layer_surface->mapped = layersurface->mapped = 0;
| ^~~~~~~~~~~~
cc1: all warnings being treated as errors
make: *** [<builtin>: dwl.o] Error 1
clang not affected
Initializing it to an empty string had broken configuring xkbcommon
through the environment (XKB_DEFAULT_OPTIONS).
Fixes: ae31391115 ("initialize rules and xkb_rules")
now client_surface()->data is a pointer to the wlr_scene_tree of clients
which allows us to not call wlr_scene_node_lower_to_bottom() for every clients
Check the wlr_layer_surface_v1_state.committed bitmask to see if we need
to rearrange. This is also what sway does.
Without this check, every commit request (even if only the attached buffer
changed) will lead to another configure event, which will lead to another
commit, etc.
This loop results in swaybg consuming 100% CPU.
Co-authored-by: Owen Rafferty <owen@owenrafferty.com>
On SIGCHLD, check to make sure the terminated process is not the
XWayland process before reaping it, allowing wlroots to waitpid() for it
successfully.
Fixes#177.
Prior to this change, if a client whose tag(s) are not currently
selected is launched or killed, no update to status was printed and
status bars being fed by printstatus() did not update newly active
or newly inactive (but unselected) tags.
SDL2 calls xdg_toplevel.unset_fullscreen() before the surface is
mapped. This causes a segfault in dwl because setfullscreen() expects
the surface to be mapped already.
Therefore, delay the setfullscreen call until the surface is mapped.
dup2 doesn’t close fds, it only duplicates them. The old ones weren’t
closed, causing problems (like dwl blocking due to the child process
never reading from the reading end, even if stdin has been closed).
All the XDG surface iterator does is iterate the main wlr_surface, then
iterate the popups. If we inline that function, we can merge part of it
with the X11 case.
It seems like there are people trying dwl who aren't as familiar with
how their distros do development, so let's give them a pointer in the
right direction.
If a transient failure occurs in wlr_output_commit, re-render until it
doesn't happen. This could possibly be removed if we decide to
implement damage tracking in the future.
Unlike with X window managers, the display socket in Wayland isn't set
up prior to starting the compositor. Because of this, you can't pipe
the compositor's output directly into a program which needs access to
$WAYLAND_DISPLAY, which is a typical setup for this purpose. Existing
scripts have been forced to create a pipe/FIFO or a temporary file as an
intermediary.
Instead, send the status info directly to stdin of the -s command, which
*does* have access to $WAYLAND_DISPLAY.
Fixes#103.
Fixes#102. The "ideal" behavior might be to ignore buttons other than
the one being used for the action, but this is super-simple and still
seems reasonable.
The wlr-output-management protocol requires that either all of the
changes from an apply request be applied successfully, in which case a
"succeeded" event is sent, or all of the changes are reverted and a
"failed" event is sent. As written, this could partially commit
changes, then fail.
Test the changes first (even for an "apply" event), then commit or
rollback as appropriate.
Additionally, variables xcursor and xcursor_mgr are only used
when xwayland is defined, so I make the variables declaration
contingent on whether xwayland is being used
I am embarrassed to have let this slip through someone's merge. Anybody
who genuinely needs to `sudo make` will know it; everyone else should
use a proper package manager and build system.
Replaces the outputOrder patch.
This avoids recalculating positions and allows to arrange monitors in
any order, not just from left to right.
The order in which monitors are defined in config.h still matters but
it's just the order in the list, not the actual position.
This is the order of *_destroy calls which resulted in the fewest
errors/leaks detected by Valgrind. Most of the errors come from the
gbm_allocator code - will have to figure out which destroy call is still
missing.
Similar to Linux kernel approach, encapsulate some of the uglier
conditional compilation into inline functions in header files.
The goal is to make dwl.c more attractive to people who embrace the
suckless philosophy - simple, short, hackable, and easy to understand.
We want dwm users to feel comfortable here, not scare them off. Plus,
if we do this right, the main dwl.c code should require only minimal
changes once XWayland is no longer a necessary evil.
According to `cloc`, this also brings dwl.c down below 2000 lines of
non-blank, non-comment code.
When a new client is spawned, fullscreen isn't disabled for all clients
in that monitor any more.
Instead, all fullscreen clients are kept fullscreen, while other clients
spawn in the background.
When fullscreen is disabled, all clients are rearranged.
This is made to make dwl more flexible allowing multiple fullscreen
clients at the same time, have floating clients on top of a fullscreen
one and let stuff happen without quitting fullscreen, like many other
WMs and DEs.
Disable fullscreen on all visible clients in that monitor also before
enabling it on another client.
quitallfullscreen() is reintroduced becouse is now more useful
set c->isfullscreen later to avoid making quitallfullscreen() disable
fullscreen on the current client
...in internal calls to restore pointer focus. Necessary for the
unclutter patch, and there's no harm in avoiding this call even in
mainline; might prevents issues in same edge cases.
- A maximum SLOC can't be reasonably determined before implementing the
missing protocols, so not any time soon
- dwl definitely isn't a simple as dwm since it must implement lots of
Wayland protocols and not just manage windows. The status bar
integration, layer shell popups, damage tracking and IME are gonna
require hundreds more lines each.
- "Buffering of input when spawning a client so you don't have to wait
for the window (use `wl_client_get_credentials` to get the PID) - would
this require passing through something like dmenu? Extension protocol?"
This sounds exoteric, if anything this should be patch.
- Can dwl really be started from within an X session? When I do it from
dwm it crashes.
- A window's texture is scaled for its "home" monitor only (noticeable
when window sits across a monitor boundary)
Gonna open a ticket for this rather than keep it in the README.
Don't let internal calls to motionnotify(0) meant to update the pointer
focus from maplayersurfacenotify and destroylayersurfacenotify also
shift the keyboard focus to the surface under the cursor with
sloppyfocus.
wtf is the point of this crap? It makes the code harder to follow,
increases the line count and made me fail compilation a million times.
We shouldn't blindy follow everything about suckless's style.
Scaling a wlr_box without rounding can sometimes make the borders not
connected and nice. I noticed this when setting scale in monrules to 1.2
So I've went and copied what Sway did in desktop/output.c but without
having a second function and now using a random rounding macro I found
on the internet so as to not use round from math.h.
Distribute it as a patch like in dwm since graphical applications
usually provide their own keybinding; I guess it's only for terminals.
Note that even though these commits don't let you open multiple windows
in fullscreen and cycle between them like in dwm, with just
fullscreennotify spawning new windows or changing tag would still exit
fullscreen automatically, but you would have to toggle fullscreen twice
when switching back to the fullscreen window to enter fullscreen again,
so this is better since it avoids that.
quitfullscreen() was replicating the functionalities of setfullscreen(c,
0)
Reusing setfullscreen() in quitfullscreen() leads to a 3 line function,
which is useless since quitfullscreen() is used once anyway
This fixes the bug that happens when changing workspace (or any time
arrange() is called) where there are fullscreen windows, which are still
fullscreen but leave the space for layer surfaces like waybar (which
should be hidden when going fullscreen)
Also as soon one fullscreen window is found hte function returns to
improve efficiency
Store position and size of windows before going fullscreen. This is more
efficient than arrange() and also works with floating windows
All the clients keep their original position because arrange() isn't
used after quitting fullscreen
Because maprequest immediately calls wl_list_insert(&fstack, &c->flink),
in the following call to setmon(), the selclient() which is passed to
focusclient() as the old client is actually the newly mapped client, and
the real old one is never deactivated. You can see this by, for example,
opening Chromium's devtools, then spawning a terminal. The background of
the focused line in the devtools doesn't change from light blue to grey.
We can't just remove wl_list_insert(&fstack, &c->flink) from maprequest,
because calling wl_list_remove in focusclient() with a client that has
not been added to the list causes a segmentation fault.
Therefore we fix the focusclient call by not passing it the old client
every time, but instead using the wlroots function that gets the focused
surface and deactivate that, like in TinyWL.
This also avoids getting the selected client and passing it to
focusclient() on every call unnecessarily, and will allow removing
shouldfocusclients in a future commit by checking if old is a layer
surface instead.
It makes wl-clipboard work properly in neovim, without having to create
a transparent surface that steals focus and causes flickering. It's also
required for clipman.
The code in this else completely freezes my system when I run the
swayidle command to replicate xset dpms force off. No idea if it works
on multiple monitors, but for now avoid running when there's 1 monitor.
Also remove the comment with the function name in sway.
Since wlr_output_enable doesn't have any effect before finishing all the
procedure, a little hack allows to make use of focusmon(), which must
know the latest in about which output is currently disabled
Also improve performance in focusmon() and cleaner code in
outputmgrapplyortest()
With the recent changes in output-management, the extra argument in
closemon() would be needed only when unplugging the monitor, so it isn't
worth it anymore. Also now is more efficient.
m->link.next leads to errors if the monitor to disable doesn't have a
"next" (right) monitor and is currently focused. dirtmon() does more
checks.
In some previous commits m->link.next is told to be left monitor, which
is wrong
Also focusclient() explicitly checks for disabled monitors (this fixes
in case of more than one disabled monitor)
Focus the top client on newmon, which we know for sure that it isn't
going to be unplugged or disabled and actually set that as the focused
monitor to move the focus. This is necessary to prevent crash when
disabling monitors with the output-management patch.
This allows to fix output-management: move clients to the monitor on the
left of the disabled one, instead of the leftmost (which might happen to
be the disabled one)
Also using wl_list_foreach() and then brake after the first iteration is
ugly and inefficient
When using wlr-randr every monitor's configuration is reevaluated, so it
must check which monitors are actually being disabled. The only way to
correctly do that is to compare the names.
When a monitor is disabled with wlr_randr, all clients on that monitor
aren't lost but they are moved to the leftmost monitor with the same
method that handles monitor hot unplug
There is no need to repeat this. This needs to be reculalculated in my
output-management implementation too, and since I'm already calling
updatemons, this patch avoids having to repeat the assignment again.
quitfullscreen() was replicating the functionalities of setfullscreen(c,
0)
Reusing setfullscreen() in quitfullscreen() leads to a 3 line function,
which is useless since quitfullscreen() is used once anyway
This fixes the bug that happens when changing workspace (or any time
arrange() is called) where there are fullscreen windows, which are still
fullscreen but leave the space for layer surfaces like waybar (which
should be hidden when going fullscreen)
Also as soon one fullscreen window is found hte function returns to
improve efficiency
Floating widndows with "x < removed monitor's width" aren't resized
(they used to disappear in negative coordinates).
Actually delete monitors when they are unplugged, recalculate sgeom and
give a new monitor to clients that were on the removed one with setmon()
arrangefloat() funcion has been exploded to save iterations in
cleanupmon().
Also if a monitor that supports auto suspension is turned off, dwl will
count it as unplugged (it will become unreachable and all clients will
be moved to the leftmost monitor). However, if at least one monitor
isn't plugged in, dwl will still crash the same as before.
Unlike sway, when the output configuration is changed and restored,
(unplug + plug the same monitor for example) previous application
positions aren't kept. This is due to the fact that on sway every
workspace is unique among all monitors.
Compensate the coordinate changes when adding a new monitor.
Every test so far confirms that monitors are always added to the left,
on top of the list, so every floating window's x coordinate has to be
incremented by the width of the new monitor.
When a monitor is created or removed, the geometries of the old ones
must be updated. This is also more efficient than before since we
calculate the monitor geometries only when creating and destroying
monitors. arrangelayers() is needed to recalculate m->w. arrange() is so
clients don't move to the left monitor when plugging or unplugging
monitors (clients keep the same coordinates but the field below them
changes).
The bug was caused by usable_area's x and y not being set in
arrangelayers. For example if on a 2nd HD monitor, x should be 1920
while the first one ends at 1919. So I don't see why m->m should be
recalculated after creating the monitor.
If you don't recalculate the monitor's geometry before arranging,
clients get arranged in the first monitor. I don't understand why this
fixes the bug since tile() uses m->w rather than m->m, nor why it needs
to be recalculated after creating the monitor but sway does it too.
Although not necessary to fix the bug I also made arrangelayer() do like
sway again and recalculate usable_area instead of reusing m->m, since
m->m seems to be incorrect until it gets recalculated shortly after in
arrange(), so I suspect that leaving usable_area = m->m will cause
issues under certain circumstances.
Someone with a multi-monitor setup or better knowledge of Wayland may be
able to figure out the cause of the bug. For now, this makes layer shell
work.
When a layer surface is destroyed focus should be returned to the last
client. Luckily if there are multiple overlays the previous overlay
still gets focused.
Store position and size of windows before going fullscreen. This is more
efficient than arrange() and also works with floating windows
All the clients keep their original position because arrange() isn't
used after quitting fullscreen
rename Layer to LayerSurface; layer should refer to overlay, top, bottom
or background
LayerSurface variables are always called layersurface
wlr_layer_surface_v1 variables are always called wlr_layer_surface
- Only report bugs that can be reproduced on the main (or wlroots-next) branch without patches.
- Proprietary graphics drivers, including nvidia, are not supported. Please use the open source equivalents, such as nouveau, if you would like to use dwl.
- Report patch issues to their respective authors.
- type:input
id:dwl_version
attributes:
label:'dwl version:'
placeholder:'`dwl -v`'
validations:
required:true
- type:input
id:wlroots_version
attributes:
label:'wlroots version:'
validations:
required:true
- type:input
id:distro
attributes:
label:What distro (and version) are you using?
validations:
required:false
- type:textarea
attributes:
label:Description
value:|
The steps you took to reproduce the problem.
validations:
required:false
- type:textarea
id:debug_log
attributes:
label:Debug Log
value:|
Run `dwl -d 2> ~/dwl.log` from a TTY and attach the **full** (do not truncate it) file here, or upload it to a pastebin.
Please try to keep the reproduction as brief as possible and exit dwl.
validations:
required:false
- type:textarea
id:backtrace
attributes:
label:Stack Trace
value:|
- Only required if dwl crashes.
- If the lines mentioning dwl or wlroots have `??`. Please compile both dwl and wlroots from source (enabling debug symbols) and try to reproduce.
dwl is a compact, hackable compositor for Wayland based on [wlroots](https://github.com/swaywm/wlroots). It is intended to fill the same space in the Wayland world that dwm does in X11, primarily in terms of philosophy, and secondarily in terms of functionality. Like dwm, dwl is:
Join us on our [Discord server]
Or Matrix: [#dwl-official:matrix.org]
Or on our IRC channel: [#dwl on Libera Chat]
dwl is a compact, hackable compositor for [Wayland] based on [wlroots]. It is
intended to fill the same space in the Wayland world that [dwm] does in X11,
primarily in terms of functionality, and secondarily in terms of
philosophy. Like [dwm], dwl is:
- Easy to understand, hack on, and extend with patches
- One C source file (or a very small number) configurable via `config.h`
- Limited to a maximum number of SLOC (to be determined)
- Tied to as few external dependencies as possible
## Getting Started:
dwl is not meant to provide every feature under the sun. Instead, like dwm, it sticks to features which are necessary, simple, and straightforward to implement given the base on which it is built. Since wlroots provides a number of features that are more complicated to accomplish with Xlib and select extensions, dwl can be in some ways more featureful than dwm *while remaining just as simple.* Intended default features are:
### Latest semi-stable [release]
This is probably where you want to start. This builds against the [wlroots]
versions currently shipping in major distributions. If your
distribution's `wlroots` version is older, use an earlier dwl [release].
The `wlroots` version against which a given `dwl` release builds is specified
with each release on the [release] page
- Any features provided by dwm/Xlib: simple window borders, tags, keybindings, client rules, mouse move/resize (see below for why the built-in status bar is a possible exception)
- Configurable multi-monitor layout support, including position and rotation
- Configurable HiDPI/multi-DPI support
- Wayland protocols needed for daily life in the tiling world: at a minimum, xdg-shell and layer-shell (for bars/menus). Protocols trivially provided by wlroots may also be added.
- XWayland support as provided by wlroots
- Zero flickering - Wayland users naturally expect that "every frame is perfect"
- Basic yes/no damage tracking to avoid needless redraws (if it can be done simply and has an impact on power consumption)
### Development branch [main]
Active development progresses on the `main` branch. The `main` branch is built
against a late (and often changing) git commit of wlroots. While the adventurous
are welcome to use `main`, it is a rocky road. Using `main` requires that the
user be willing to chase git commits of wlroots. Testing development pull
requests may involve merging unmerged pull requests in [wlroots]' git repository
and/or git commits of wayland.
### Building dwl
dwl has the following dependencies:
- libinput
- wayland
- wlroots (compiled with the libinput backend)
- xkbcommon
- wayland-protocols (compile-time only)
- pkg-config (compile-time only)
dwl has the following additional dependencies if XWayland support is enabled:
- libxcb
- libxcb-wm
- wlroots (compiled with X11 support)
- Xwayland (runtime only)
Other features under consideration are:
- Additional Wayland compositor protocols which are trivially provided by wlroots or can be conditionally included via `config.h` settings (e.g. screen capture)
- External bar support instead of a built-in status bar, to avoid taking a dependency on FreeType or Pango
- Buffering of input when spawning a client so you don't have to wait for the window (use `wl_client_get_credentials` to get the PID) - would this require passing through something like dmenu? Extension protocol?
- More in-depth damage region tracking
Feature *non-goals* include:
- Client-side decoration (any more than is necessary to tell the clients not to)
- Client-initiated window management, such as move, resize, and close, which can be done through the compositor
## Building dwl
dwl has only two dependencies: wlroots (git version currently required) and wayland-protocols. Simply install these and run `make`.
Install these (and their `-devel` versions if your distro has separate
development packages) and run `make`. If you wish to build against a released
version of wlroots (*you probably do*), use a [release] or a [0.x branch]. If
you want to use the unstable development `main` branch, you need to use the git
version of [wlroots].
To enable XWayland, you should uncomment its flags in `config.mk`.
## Configuration
All configuration is done by editing `config.h` and recompiling, in the same manner as dwm. There is no way to separately restart the window manager in Wayland without restarting the entire display server, so any changes will take effect the next time dwl is executed.
All configuration is done by editing `config.h` and recompiling, in the same
manner as [dwm]. There is no way to separately restart the window manager in
Wayland without restarting the entire display server, so any changes will take
effect the next time dwl is executed.
As in the [dwm] community, we encourage users to share patches they have
created. Check out the [dwl-patches] repository!
## Running dwl
dwl can be run as-is, with no arguments. In an existing Wayland or X11 session, this will open a window to act as a virtual display. When run from a TTY, the Wayland server will take over the entire virtual terminal. Clients started by dwl will have `WAYLAND_DISPLAY` set in their environment, and other clients can be started from outside the session by setting this variable accordingly.
dwl can be run on any of the backends supported by wlroots. This means you can
run it as a separate window inside either an X11 or Wayland session, as well as
directly from a VT console. Depending on your distro's setup, you may need to
add your user to the `video` and `input` groups before you can run dwl on a
VT. If you are using `elogind` or `systemd-logind` you need to install polkit;
otherwise you need to add yourself in the `seat` group and enable/start the
seatd daemon.
You can also specify a startup program using the `-s` option. The argument to this option will be run at startup as a shell command (using `sh -c`) and can serve a similar function to `.xinitrc`: starting a service manager or other startup applications. Unlike `.xinitrc`, the display server will not shut down when this process terminates. Instead, as dwl is shutting down, it will send this process a SIGTERM and wait for it to terminate (if it hasn't already). This makes it ideal not only for initialization but also for execing into a user-level service manager like s6 or `systemd --user`.
When dwl is run with no arguments, it will launch the server and begin handling
any shortcuts configured in `config.h`. There is no status bar or other
decoration initially; these are instead clients that can be run within the
Wayland session. Do note that the default background color is grey. This can be
modified in `config.h`.
More/less verbose output can be requested with flags as well:
If you would like to run a script or command automatically at startup, you can
specify the command using the `-s` option. This command will be executed as a
shell command using `/bin/sh -c`. It serves a similar function to `.xinitrc`,
but differs in that the display server will not shut down when this process
terminates. Instead, dwl will send this process a SIGTERM at shutdown and wait
for it to terminate (if it hasn't already). This makes it ideal for execing into
a user service manager like [s6], [anopa], [runit], [dinit], or [`systemd
--user`].
*`-q`: quiet (log level WLR_SILENT)
*`-v`: verbose (log level WLR_INFO)
*`-d`: debug (log level WLR_DEBUG)
Note: Wayland requires a valid `XDG_RUNTIME_DIR`, which is usually set up by a session manager such as `elogind` or `systemd-logind`. If your system doesn't do this automatically, you will need to configure it prior to launching `dwl`, e.g.:
Note: The`-s` command is run as a *child process* of dwl, which means that it
does not have the ability to affect the environment of dwl or of any processes
that it spawns. If you need to set environment variables that affect the entire
dwl session, these must be set prior to running dwl. For example, Wayland
requires a valid `XDG_RUNTIME_DIR`, which is usually set up by a session manager
such as `elogind` or `systemd-logind`. If your system doesn't do this
automatically, you will need to configure it prior to launching `dwl`, e.g.:
export XDG_RUNTIME_DIR=/tmp/xdg-runtime-$(id -u)
mkdir -p $XDG_RUNTIME_DIR
dwl
### Status information
## Known limitations and issues
Information about selected layouts, current window title, app-id, and
selected/occupied/urgent tags is written to the stdin of the `-s` command (see
the `STATUS INFORMATION` section in `_dwl_(1)`). This information can be used to
populate an external status bar with a script that parses the
information. Failing to read this information will cause dwl to block, so if you
do want to run a startup command that does not consume the status information,
you can close standard input with the `<&-` shell redirection, for example:
dwl is a work in progress, and it has not yet reached its feature goals in a number of ways:
dwl -s 'foot --server <&-'
- A window's texture is scaled for its "home" monitor only (noticeable when window sits across a monitor boundary)
- XWayland support is new and could use testing
- Urgent/attention/focus-request ([not yet supported](https://gitlab.freedesktop.org/wayland/wayland-protocols/-/merge_requests/9) by xdg-shell protocol)
- Statusbar support (built-in or external)
- layer-shell
- Damage tracking
- Fullscreen/fixed windows (or whatever the Wayland analogues are)
If your startup command is a shell script, you can achieve the same inside the
script with the line
exec <&-
To get a list of status bars that work with dwl consult our [wiki].
### (Known) Java nonreparenting WM issue
Certain IDEs don't display correctly unless an environmental variable for Java AWT
indicates that the WM is nonreparenting.
For some Java AWT-based IDEs, such as Xilinx Vivado and Microchip MPLAB X, the
following environment variable needs to be set before running the IDE or dwl:
export _JAVA_AWT_WM_NONREPARENTING=1
## Replacements for X applications
You can find a [list of useful resources on our wiki].
## Background
dwl is not meant to provide every feature under the sun. Instead, like [dwm], it
sticks to features which are necessary, simple, and straightforward to implement
given the base on which it is built. Implemented default features are:
- Any features provided by [dwm]/Xlib: simple window borders, tags, keybindings,
client rules, mouse move/resize. Providing a built-in status bar is an
exception to this goal, to avoid dependencies on font rendering and/or drawing
libraries when an external bar could work well.
- Configurable multi-monitor layout support, including position and rotation
- Configurable HiDPI/multi-DPI support
- Idle-inhibit protocol which lets applications such as mpv disable idle
monitoring
- Provide information to external status bars via stdout/stdin
- Urgency hints via xdg-activate protocol
- Support screen lockers via ext-session-lock-v1 protocol
- Various Wayland protocols
- XWayland support as provided by wlroots (can be enabled in `config.mk`)
- Zero flickering - Wayland users naturally expect that "every frame is perfect"
- Layer shell popups (used by Waybar)
- Damage tracking provided by scenegraph API
Given the Wayland architecture, dwl has to implement features from [dwm] **and**
the xorg-server. Because of this, it is impossible to maintain the original
project goal of 2000 SLOC and have a reasonably complete compositor with
features comparable to [dwm]. However, this does not mean that the code will grow
indiscriminately. We will try to keep the code as small as possible.
Features under consideration (possibly as patches) are:
- Protocols made trivial by wlroots
- Implement the text-input and input-method protocols to support IME once ibus
implements input-method v2 (see https://github.com/ibus/ibus/pull/2256 and
https://codeberg.org/dwl/dwl/pulls/235)
Feature *non-goals* for the main codebase include:
- Client-side decoration (any more than is necessary to tell the clients not to)
- Client-initiated window management, such as move, resize, and close, which can
be done through the compositor
- Animations and visual effects
## Acknowledgements
dwl began by extending the TinyWL example provided (CC0) by the sway/wlroots developers. This was made possible in many cases by looking at how sway accomplished something, then trying to do the same in as suckless a way as possible. Speaking of which, many thanks to suckless.org and the dwm developers and community for the inspiration.
dwl began by extending the TinyWL example provided (CC0) by the sway/wlroots
developers. This was made possible in many cases by looking at how sway
accomplished something, then trying to do the same in as suckless a way as
possible.
Many thanks to suckless.org and the [dwm] developers and community for the
inspiration, and to the various contributors to the project, including:
- **Devin J. Pohly for creating and nurturing the fledgling project**
- Alexander Courtis for the XWayland implementation
- Guido Cella for the layer-shell protocol implementation, patch maintenance,
and for helping to keep the project running
- Stivvo for output management and fullscreen support, and patch maintenance
/* See LICENSE.dwm file for copyright and license details. */
voiddie(constchar*fmt,...);
void*ecalloc(size_tnmemb,size_tsize);
intfd_set_nonblock(intfd);
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
thanatos