// Grab Alt+Tab
        xlib::XGrabKey(
            display,
            tab_key,
            alt_mask,
            root_window,
            1,
            xlib::GrabModeAsync,
            xlib::GrabModeAsync,
        );

        loop {
            let mut event: xlib::XEvent = std::mem::zeroed();
            xlib::XNextEvent(display, &mut event);

            match event.get_type() {
                xlib::KeyPress => {
                    log::debug!("Alt+Tab Pressed [X11]");
                    state::IS_VISIBLE.store(true, Ordering::SeqCst);
                    let index = state::SELECTED_INDEX.load(Ordering::SeqCst);
                    state::SELECTED_INDEX.store(index + 1, Ordering::SeqCst);
                    state::SELECTED_INDEX_CHANGED.store(true, Ordering::SeqCst);
                }
                xlib::KeyRelease => {
                    let xkey = xlib::XKeyEvent::from(event);
                    if xkey.keycode == alt_key as u32 {
                        state::IS_VISIBLE.store(false, Ordering::SeqCst);
                        state::SELECTED_INDEX.store(-1, Ordering::SeqCst);
                        state::SELECTED_INDEX_CHANGED.store(true, Ordering::SeqCst);
                    }
                    if xkey.keycode == tab_key as u32 {
                        //
                    }
                }
                _ => {}
            }
        }

let controller = EventControllerKey::new();
let window_clone = window.clone();
let tabs_clone = tabs.clone();
controller.connect_key_released(
    move |_, keyval, _, _| match keyval.name().unwrap().as_str() {
        "Alt_L" => {
            log::debug!("Alt_L released [GTK]");
            window_clone.hide();
            state::IS_VISIBLE.store(false, Ordering::SeqCst);

            {
                let mut tabs = tabs_clone.write().unwrap();
                tabs.reorder_prev_first();
            }

            state::SELECTED_INDEX.store(-1, Ordering::SeqCst);

            let surface = window_clone.surface().unwrap();
            let display = window_clone.display();
            let monitor = display.monitor_at_surface(&surface).unwrap();
            let monitor_name = monitor.model().unwrap();

            // ...
        }
        _ => {}
    },
);
window.add_controller(controller);

I can think of two different ways around this.

1. Select KeyReleaseMask for all windows (and keep track of appearing and disappearing windows); or
2. Once you know Alt is pressed, poll the keyboard state with XQueryKeyboard every 0.1 second or so until it's released.

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <stdbool.h>
#include <stdio.h>

void dowin (Display* dpy, Window win, int reg)
{
  Window root, parent;
  Window* children;
  int nchildren, i;

  XSelectInput (dpy, win, reg ? KeyReleaseMask|SubstructureNotifyMask : 0);
  XQueryTree (dpy, win, &root, &parent, &children, &nchildren);

  for (i = 0; i < nchildren; ++i)
  {
    dowin (dpy, children[i], reg);
  }

  XFree(children);
}


int main()
{
    Display*    dpy     = XOpenDisplay(0);
    Window      win     = DefaultRootWindow(dpy);
    XEvent      ev;

    unsigned int    alt_modmask       = Mod1Mask;
    unsigned int    ignored_modmask   = 0; // stub
    KeyCode         tab_keycode       = XKeysymToKeycode(dpy,XK_Tab);
    KeyCode         alt_keycode       = XKeysymToKeycode(dpy,XK_Alt_L);

    dowin (dpy, win, True);

    XGrabKey (dpy,
            tab_keycode,
            alt_modmask | ignored_modmask,
            win,
            True,
            GrabModeAsync, GrabModeAsync);


    while(true)
    {
        ev.xkey.keycode = 0;
        ev.xkey.state = 0;
        ev.xkey.type = 0;

        XNextEvent(dpy, &ev);
        switch(ev.type)
        {
            case KeyPress:
                printf ("Press %x: d-%d\n", ev.xkey.window, ev.xkey.state, ev.xkey.keycode);
                break;

            case KeyRelease:
                printf ("Release %x: %d-%d\n", ev.xkey.window, ev.xkey.state, ev.xkey.keycode);
                break;

            case MapNotify:
                printf ("Mapped %x\n", ev.xmap.window);
                dowin (dpy, ev.xmap.window, True);
                break;

            case UnmapNotify:
                printf ("Unmapped %x\n", ev.xunmap.window);
                dowin (dpy, ev.xunmap.window, False);
                break;

            default:
                printf ("Event type %d\n", ev.type);
                break;
        }

    }

    XCloseDisplay(dpy);
    return 0;
}

unsafe fn dowin(dpy: *mut Display, win: Window, reg: bool) {
    let mut root: Window = 0;
    let mut parent: Window = 0;
    let mut children: *mut Window = std::ptr::null_mut();
    let mut nchildren: u32 = 0;

    // Convert reg to the desired event mask or 0 if reg is false.
    let event_mask = if reg {
        x11::xlib::KeyReleaseMask | x11::xlib::SubstructureNotifyMask
    } else {
        0
    };

    // Select input events on the current window based on `reg`.
    XSelectInput(dpy, win, event_mask as i64);

    // Query the window tree to get its children.
    XQueryTree(
        dpy,
        win,
        &mut root,
        &mut parent,
        &mut children,
        &mut nchildren,
    );

    // Recursively call `dowin` on each child.
    for i in 0..nchildren as isize {
        dowin(dpy, *children.offset(i), reg);
    }

    // Free the list of children windows to avoid memory leaks.
    XFree(children as *mut std::ffi::c_void);
}