hypridle doesn't wait for animation to finish before suspend

[danielepintore]

Problem Description

Hello, first of all thanks for your software. I've been using hyprlock and hypridle for a while now. But there is a problem that seems I can't fix it:
After I suspend my system with systemctl suspend or I close the lid of my laptop, when I wake up the system I see for a split second a flash with the screen content. I think the problem is the fact that the animations are active on hyprlock, because when I disable them the problem seems to be fixed.
Seems that the lock given from hyprlock-lock-notify-v1 it's a little early if animations are enabled.

What I've tried to fix

I've tried to change the inhibit_sleep value to 3 without any luck. I've also tried to change my hyprlock and hypridle config to the default one without any luck.

Hyprland 0.48.1 built from branch at commit 29e2e59fdbab8ed2cc23a20e3c6043d5decb5cdc (version: bump to v0.48.1).
Date: Fri Mar 28 16:16:07 2025
Tag: v0.48.1, commits: 5937
built against:
aquamarine 0.8.0
hyprlang 0.6.1
hyprutils 0.7.0
hyprcursor 0.1.12
hyprgraphics 0.1.3

P.S. I'm using uwsm and i have activated the hypridle service

Hyprlock config

Hyprlock version v0.8.2

background {
    monitor =
    path = ~/.config/hypr/wallpapers/background.jpg
    color = rgba(25, 20, 20, 1.0)

    # all these options are taken from hyprland, see https://wiki.hyprland.org/Configuring/Variables/#blur for explanations
    blur_passes = 3
    blur_size = 8
    contrast = 0.8916
    brightness = 0.7172
    vibrancy = 0.1696
    vibrancy_darkness = 0
}

#animations {
#	enabled = false
#}

input-field {
    monitor =
    size = 300, 30
    outline_thickness = 0
    dots_size = 0.25 # Scale of input-field height, 0.2 - 0.8
    dots_spacing = 0.55 # Scale of dots' absolute size, 0.0 - 1.0
    dots_center = true
    dots_rounding = -1
    outer_color = rgba(242, 243, 244, 0)
    inner_color = rgba(242, 243, 244, 0)
    font_color = rgba(242, 243, 244, 0.75)
    fade_on_empty = false
    placeholder_text = # Text rendered in the input box when it's empty.
    hide_input = false
    check_color = rgba(204, 136, 34, 0)
    fail_color = rgba(204, 34, 34, 0) # if authentication failed, changes outer_color and fail message color
    fail_text = $FAIL <b>($ATTEMPTS)</b> # can be set to empty
    capslock_color = -1
    numlock_color = -1
    bothlock_color = -1 # when both locks are active. -1 means don't change outer color (same for above)
    invert_numlock = false # change color if numlock is off
    swap_font_color = false # see below
    position = 0, -470
    halign = center
    valign = center
}

label {
  monitor =
  text = cmd[update:1000] echo "$(date +"%A, %B %d")"
  color = rgba(242, 243, 244, 0.75)
  font_size = 20
  font_family = SF Pro Display Bold
  position = 0, 400
  halign = center
  valign = center
}

label {
  monitor = 
  text = $TIME
  color = rgba(242, 243, 244, 0.75)
  font_size = 93
  font_family = SF Pro Display Bold
  position = 0, 253
  halign = center
  valign = center
}

label {
    monitor =
    text = $USER
    color = rgba(242, 243, 244, 0.75)
    font_size = 12
    font_family = SF Pro Display Bold
    position = 0, -407
    halign = center
    valign = center
}

label {
    monitor =
    text = Enter Password
    color = rgba(242, 243, 244, 0.75)
    font_size = 10
    font_family = SF Pro Display
    position = 0, -440
    halign = center
    valign = center
}

Hypridle config

hypridle v0.1.6

general {
    lock_cmd = pidof hyprlock || hyprlock											# dbus/sysd lock command (loginctl lock-session)
    before_sleep_cmd = playerctl stop; loginctl lock-session							# command ran before sleep
    after_sleep_cmd = hyprctl dispatch dpms on  # to avoid having to press a key twice to turn on the display.
}

listener {
    timeout = 360                            # in seconds
    on-timeout = loginctl lock-session										 # command to run when timeout has passed
}

listener {
    timeout = 600                            # in seconds
    on-timeout = systemctl suspend										 # command to run when timeout has passed
}

Thanks for any help!

[IiroUllin]

The problem seems to be that before_sleep_cmd doesn't actually execute before the user is frozen by systemd-suspend, so effectively hyperlock starts after the system has already woken up.

After some tinkering, I found that an acceptable solution for me was to hack systemd directly, delaying its suspend service by 0.6s (would be something else for you). To do that, e.g., create /etc/systemd/system/user-suspend@.service with

[Unit]
Description=Delay Suspend by 0.6s
Before=sleep.target

[Service]
User=%i
Type=oneshot
ExecStart=/usr/bin/bash -c "sleep 0.6"

[Install]
WantedBy=sleep.target

inside and then enable/start the service via # systemctl enable --now user-suspend@<USER>.service Here <USER> is the user who'd be running the service. You may also change ExecStart if needed for your setup. Hopefully this works for you!

[danielepintore]

Thanks, I’ll try that. Hopefully somedays this problem will be fixed

[Vladimir-csp]

I see hypridle's inhibition in systemd-inhibit --list. Is it being released early?

[danielepintore]

Here what I've found using this config:

general {
    lock_cmd = date > ~/lock-idle.log
    before_sleep_cmd = sleep 2 && pidof hyprlock || hyprlock
    after_sleep_cmd = hyprctl dispatch dpms on
}

Running this seems that hypridle waits 2 seconds before suspending the system. But there is something strange:

Given the output of journalctl -u systemd-logind.service:

Jul 02 16:06:18 thinkpad systemd-logind[972]: The system will suspend now!
Jul 02 16:06:24 thinkpad systemd-logind[972]: Operation 'suspend' finished.

and the lock-idle.log file contains:

Wed Jul  2 04:06:27 PM CEST 2025

It seems that the lock command is being executed after the system has finished suspending, and with a noticeable delay

[danielepintore]

little update:
I have installed swaylock. Using it with hypridle seems to work fine. Can anyone else try this? Maybe it is a hyprlock problem.
I'm using the same configuration that is in my first comment.

I'm more confused than before 😕

general {
lock_cmd = pidof hyprlock || hyprlock # dbus/sysd lock command (loginctl lock-session)
before_sleep_cmd = playerctl stop; loginctl lock-session # command ran before sleep
after_sleep_cmd = hyprctl dispatch dpms on # to avoid having to press a key twice to turn on the display.
}

listener {
timeout = 360 # in seconds
on-timeout = loginctl lock-session # command to run when timeout has passed
}

listener {
timeout = 600 # in seconds
on-timeout = systemctl suspend # command to run when timeout has passed
}

[IiroUllin]

@Vladimir-csp yes, something like that. It seems that hypridle fires off its before_sleep_cmd but doesn't wait until it finishes and gives the reigns back to systemd. The latter immediately freezes user space processes, so pretty much everything that in before_sleep_cmd then only runs after the suspend is over...

[IiroUllin]

@danielepintore It's possible that swaylock is very quick and manages to lock the system before its frozen. But I think the main issue is that before_sleep_cmd is kind of misleading as it is right now: it really only starts executing right before suspension, however, there is no mechanism in place to wait until it finishes. My solution was just to add a bit of delay to systemd-suspend itself, but it's not particularly elegant, as that delay must be hand-tuned. The proper solution would be to have hypridle wait until its before_sleep_cmd finishes running and only then release its lock, but I remember reading in some other thread that it's not going to happen. (Regrettably, but also understandably so, as it's not trivial or even possible in the most general circumstances.)

[danielepintore]

yes, you are right, using sleep 3 && swaylock as the lock command results in the same behavior

[PointerDilemma]

But I think the main issue is that before_sleep_cmd is kind of misleading as it is right now: it really only starts executing right before suspension, however, there is no mechanism in place to wait until it finishes.

This^! However, hyprland-lock-notify-v1 and hypridles inhibit_sleep option is intended to be the mechanism that guaranties the system fully locks before going to sleep.

The feature not working can have 2 different causes.

1. Your system doesn't let hypridle inhibit when it needs to, there is a bug in hypridles sleep inhibition, or you don't have inhibit_sleep set to auto (and it is enabled with "wait until locked") or 3, or your logind configuration doesn't allow hyprlidle to inhibit sleep.
   Identifying this is can be done when examining hypridle logs. So I encourage you to post your hypridle logs here.
2. Hypridle successfully inhibits sleep and releases it at the right time, but hyprlock doesn't manage to actually draw a frame that covers the screen with it's own content. On the one hand this is a problem with fade-in. You will need --no-fade-in, because the fade in is something that the Hyprland doesn't know about and the hyprland-lock-notify protocol is intended to work for all session-lock clients. On the other hand, hyprlock before core: use a screenshot for fade in/out hyprlock#726 (so 0.8.2) has some edge cases in the background widget that may lead to the first frame being leaky. That goes together with session-lock: don't render workspaces when locked Hyprland#10865 which will guaranty that workspaces wont be rendered any more when hypridle recieves lock from hyprland-lock-notifiy.

Generally about the hyprland-lock-notify protocol: The notification for locked only gets sent, when all monitors of your session get covered with one lock-screen frame. (See this code)

If you are willing to test the stuff I have been working on to fix this problem, do this:

1. Use hyprlock git.
2. Compile and run this pr session-lock: don't render workspaces when locked Hyprland#10865 (Or wait until it's merged)
3. Use --no-fade-in when locking before sleep. I suggest a config like this (this way, --no-fade-in is only used when locking before sleep):

   general {
       lock_cmd = hyprlock
       before_sleep_cmd = hyprlock --no-fade-in
       after_sleep_cmd = hyprctl dispatch dpms on
   }
   

4. Make sure that hypridle logs Sleep inhibition enabled - inhibiting until the wayland session gets locked when it start's up.
5. Before locking, check systemd-inhibit --list to verifiy hypridle successfully inhibits sleep.

When everything works as intended, you do systemctl suspend (keep in mind! something like rtcwake or other utilities do not respect systemd's sleep inhibit!)
Since hypridle has inhibited sleep, sleep will not hit immediately. hypridle recieves "PrepareForSleep" from systemd dbus and launches your before_sleep_cmd. Hypridle does not release the sleep inhibitor after it launched before_sleep_cmd. Sleep is still inhibited. Meanwhile hyprlock starts up and locks the session. When hyprlock commited a lock-surface for each output (aka. it covered all monitors), the compositor (Hyprland) will notify Hypridle that the session was locked and thus hypridle will release the inhibitor and the system can go to sleep. This is how it is supposed to work.

[danielepintore]

After some time tinkering I've finally found and implemented a proper fix. This requires changes in hyprlock and hypridle.

At the moment hypridle inhibits the system from suspend, launches the lock_cmd and other commands that should run before the sleep, then releases the inhibit lock. The problem with this approach is that sometimes, due to the speed of the computer or due to the configuration of hyprlock this can cause the system to go to sleep before the lock application has finished to launch.

This can be easily reproduced by slowing the animation on hyprlock:

animations {
		enabled = true
		animation = fade, 1, 15, linear
}

In order to fix this problem we need a way to know when the lock has finished drawing the transition (the animation), wait and then release the suspend lock.
This is feasible since when we acquire the delay type of inhibit, logind will wait a maximum of 5 seconds and the force the suspend anyway.

I'm not a C++ programmer but I managed to implement a janky proof of concept.

hypridle.patch

diff --git a/src/core/Hypridle.cpp b/src/core/Hypridle.cpp
index 13537c7..13fb586 100644
--- a/src/core/Hypridle.cpp
+++ b/src/core/Hypridle.cpp
@@ -6,6 +6,7 @@
 #include <sys/wait.h>
 #include <sys/poll.h>
 #include <sys/mman.h>
+#include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <algorithm>
@@ -324,13 +325,26 @@ void CHypridle::onInhibit(bool lock) {
     Debug::log(LOG, "Inhibit locks: {}", m_iInhibitLocks);
 }
 
+void CHypridle::waitForLockfileRemoval(const char* lockfile, std::chrono::milliseconds interval) {
+    struct stat st;
+    while (::stat(lockfile, &st) == 0) {
+        std::this_thread::sleep_for(interval);
+    }
+}
+
 void CHypridle::onLocked() {
     Debug::log(LOG, "Wayland session got locked");
     m_isLocked = true;
 
-    static const auto LOCKCMD = g_pConfigManager->getValue<Hyprlang::STRING>("general:on_lock_cmd");
-    if (!std::string{*LOCKCMD}.empty())
-        spawn(*LOCKCMD);
+    static const auto ONLOCKCMD = g_pConfigManager->getValue<Hyprlang::STRING>("general:on_lock_cmd");
+    static const auto LOCKCMD = g_pConfigManager->getValue<Hyprlang::STRING>("general:lock_cmd");
+
+    if (!std::string{*ONLOCKCMD}.empty())
+        spawn(*ONLOCKCMD);
+
+    if (std::string{*LOCKCMD}.contains("hyprlock"))
+        waitForLockfileRemoval("/tmp/hyprlock.lock"); // we have max 5 seconds to delete the lock or logind will continue anyway
+                                                      // the 5 seconds is the time that logind waits for delay inhibit
 
     if (m_inhibitSleepBehavior == SLEEP_INHIBIT_LOCK_NOTIFY)
         uninhibitSleep();
diff --git a/src/core/Hypridle.hpp b/src/core/Hypridle.hpp
index 395b07c..3410c82 100644
--- a/src/core/Hypridle.hpp
+++ b/src/core/Hypridle.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <chrono>
 #include <memory>
 #include <vector>
 #include <sdbus-c++/sdbus-c++.h>
@@ -53,6 +54,7 @@ class CHypridle {
   private:
     void    setupDBUS();
     void    enterEventLoop();
+    void    waitForLockfileRemoval(const char* lockfile, std::chrono::milliseconds interval = std::chrono::milliseconds(100));
 
     bool    m_bTerminate    = false;
     bool    isIdled         = false;

hyprlock.patch

diff --git a/src/core/hyprlock.cpp b/src/core/hyprlock.cpp
index 0b5fa69..f8478d5 100644
--- a/src/core/hyprlock.cpp
+++ b/src/core/hyprlock.cpp
@@ -6,6 +6,7 @@
 #include "../auth/Auth.hpp"
 #include "../auth/Fingerprint.hpp"
 #include "Egl.hpp"
+#include "src/helpers/MiscFunctions.hpp"
 #include <chrono>
 #include <hyprutils/memory/UniquePtr.hpp>
 #include <sys/wait.h>
@@ -239,6 +240,7 @@ void CHyprlock::addDmabufListener() {
 }
 
 void CHyprlock::run() {
+    spawnAsync("touch /tmp/hyprlock.lock");
     m_sWaylandState.registry = makeShared<CCWlRegistry>((wl_proxy*)wl_display_get_registry(m_sWaylandState.display));
     m_sWaylandState.registry->setGlobal([this](CCWlRegistry* r, uint32_t name, const char* interface, uint32_t version) {
         const std::string IFACE = interface;
diff --git a/src/renderer/Renderer.cpp b/src/renderer/Renderer.cpp
index 41bdb0a..7716045 100644
--- a/src/renderer/Renderer.cpp
+++ b/src/renderer/Renderer.cpp
@@ -12,6 +12,7 @@
 #include <GLES3/gl3ext.h>
 #include <GLES2/gl2ext.h>
 #include <algorithm>
+#include "src/helpers/MiscFunctions.hpp"
 #include "widgets/PasswordInputField.hpp"
 #include "widgets/Background.hpp"
 #include "widgets/Label.hpp"
@@ -610,7 +611,12 @@ void CRenderer::startFadeIn() {
     Debug::log(LOG, "Starting fade in");
     *opacity = 1.f;
 
-    opacity->setCallbackOnEnd([this](auto) { opacity->setConfig(g_pConfigManager->m_AnimationTree.getConfig("fadeOut")); }, true);
+    opacity->setCallbackOnEnd(
+        [this](auto) {
+            opacity->setConfig(g_pConfigManager->m_AnimationTree.getConfig("fadeOut"));
+            spawnAsync("rm /tmp/hyprlock.lock");
+        },
+        true);
 }
 
 void CRenderer::startFadeOut(bool unlock) {

Then you need to apply these patches to hypridle and hyprlock. These patches allow to hyprlock to generate a lockfile in the startup and delete it when the transition is over. hypridle waits for the lockfile and then inhibits the suspend.
I think this can done in a more polished way avoiding the lockfile and maybe sending some kind of signal, but I'm not a c++ programmer and I don't know how to do it. But this simple approach will fix this bug.

[PointerDilemma]

Bro, did you even read my comment??

[danielepintore]

@PaideiaDilemma For me the problem is with the fade in animation, if it takes too long to finish it will cause this problem. I'll wait until #10865 gets merged and give it a try. But I think from a ux standpoint that the user should see the screen to lock with the transition that it's selected, then suspend the system.

[PointerDilemma]

We discussed and thought about how to solve the locking race when suspending quite a bit and opted for a solution that works with all session-lock clients.
That sadly means you need to use --no-fade-in in your before_sleep_cmd.