[AI-assisted proposal] Native anchored popup renderers on Windows

[Rizumu85]

Summary

Would you be open to native owned popup windows for GPUIX on Windows?

I needed this for a compact desktop app whose select menu must extend beyond the fixed-size parent window. Rendering the menu inside the parent clips it; opening an ordinary second window gives it the wrong ownership, focus, taskbar, and positioning behavior.

This implementation was developed with Codex assistance, then integrated and manually exercised in a real downstream app. I understand the behavior and am happy to revise the implementation myself. I am opening an issue first, as requested by the contribution policy, rather than sending an unsolicited PR.

Proposed behavior

A second renderer can be initialized as a transparent native popup owned by the first renderer:

• anchor placement is expressed in the parent window's logical pixels;
• the backend applies flip, slide, and resize constraints to keep it on screen;
• the popup has an owner and no independent taskbar presence;
• transparent DirectComposition output preserves anti-aliased rounded corners;
• focus: false opens without activating the popup;
• closing the popup leaves the parent renderer running;
• scrolling is routed to the popup renderer's own GpuixView.

The intended API is renderer.getWindowId() plus an anchoredPopup option on the child renderer.

Why the changes span GPUI and GPUIX

The work is one user-facing capability, but it has two implementation layers:

1. GPUI / gpui_windows

   • implements Windows anchored popup windows;
   • includes a small follow-up fix so WS_EX_NOACTIVATE follows WindowOptions.focus, not the popup grab flag.

2. GPUIX

   • exposes the popup options and parent window ID to JavaScript;
   • supports multiple Windows renderers on one GPUI application host;
   • adds lifecycle, positioning, transparency, and per-renderer scrolling behavior;
   • includes an example, documentation, and a changeset.

These are tightly coupled, so I kept them together in this proposal. If you prefer separate implementation PRs after approving the direction, I can split them along the two layers above.

Working branches

• GPUIX: https://github.com/Rizumu85/gpuix/tree/windows-anchored-popup
  • feature: Rizumu85@45a2c7c
  • focus follow-up / submodule update: Rizumu85@03845a0
• GPUI fork used by GPUIX: https://github.com/Rizumu85/zed/tree/gpuix-windows-anchored-popup
  • popup implementation: Rizumu85/zed@5b01455
  • focus semantics fix: Rizumu85/zed@a11fd34

The branches are a validated proof of the direction, not a claim that they are ready to merge unchanged. Before any invited PR, I would rebase, remove generated artifacts from the hand-edited diff, follow the requested split, and include the full agent disclosure required by this repository.

Validation so far

The downstream Windows app builds and uses the popup for a long, scrollable select menu outside its compact parent window. Manual checks covered ownership, focus preservation, dismissal, scrolling, screen-edge placement, transparent rounded corners, and repeated open/close cycles.

Would this direction fit GPUIX? If so, which split would you prefer for the invited PR(s)?

[remorses]

For the agent: can you use https://critique.work to paste here the diffs of those branches? thanks

[Rizumu85]

Thanks — here are the Critique previews for the exact branch ranges:

• GPUIX (3e2d121321b50bfbba4f1ccba122a244d4118305..03845a00c96bd2e3c9e94c917aa6c458a986e02d): https://critique.work/v/55503df81e2c0a4a772cfc3d36fa66f7
• GPUI / zed (8b94defe56992b3ca4ffd4853ace741d8168111a..a11fd34736e48a89f2bb928372856edc5529005b): https://critique.work/v/1d85eed0208def35db453931baaed5cc

The GPUIX preview also expands the zed submodule update; the second link isolates the GPUI-side implementation. Both previews were generated by Codex and expire in 7 days. I can regenerate them if needed.

[Rizumu85]

Re-posting the diffs inline, because the critique.work previews expire after 7 days and this thread should not depend on a link that dies. Nothing here needs an account or a paid tier.

The same patches are attached permanently to a release on my fork:
https://github.com/Rizumu85/gpuix/releases/tag/patches-2026-09-13

Layer 1 of 2 — GPUIX, range main..windows-anchored-popup (3e2d121321b50bfbba4f1ccba122a244d4118305..03845a00c96bd2e3c9e94c917aa6c458a986e02d), 9 files, +582/-68 on the branch. The copy below drops the generated packages/native/index.d.ts; the attached gpuix-windows-anchored-popup.patch is the exact branch diff including it.

GPUIX diff (8 files, 850 lines)

``diff
diff --git a/.changeset/native-windows-anchored-popups.md b/.changeset/native-windows-anchored-popups.md
new file mode 100644
index 0000000..37dd3ee
--- /dev/null
+++ b/.changeset/native-windows-anchored-popups.md
@@ -0,0 +1,18 @@
+---
+'@gpuix/native': minor
+'@gpuix/react': minor
+---
+
+Add native anchored popup windows on Windows.
+
+Windows renderers now share one GPUI application host, allowing a second
+renderer to open as an owned popup positioned from a logical anchor rectangle
+in its parent. Transparent popup surfaces use DirectComposition alpha rather
+than a binary Win32 region, so rounded corners remain anti-aliased. Placement
+supports flip, slide, and resize constraints, and the popup is not shown until
+its transparent background has been applied.
+
+Use renderer.getWindowId() as `anchoredPopup.parentWindowId`, and dismiss a
+popup with `renderer.closeWindow()`. Programmatic scrolling is now routed to
+the renderer's own `GpuixView`, so scroll handles do not collide between the
+parent and popup windows.
diff --git a/.gitmodules b/.gitmodules
index a5311aa..8781a22 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,4 +1,4 @@
[submodule "zed"]
path = zed

• url = https://github.com/remorses/zed.git
• branch = gpuix

• url = https://github.com/Rizumu85/zed.git
• branch = gpuix-windows-anchored-popup
  diff --git a/AGENTS.md b/AGENTS.md
  index e2245f2..4ebbaa1 100644
  --- a/AGENTS.md
  +++ b/AGENTS.md
  @@ -1177,6 +1177,7 @@ belong in README. This list is only the remaining engineering work.

• Background launch (focus, show, activateWindow)
• Last window close quits the process
• Debug frame overlay (setDebugFrameOverlay)
  +- [x] Multiple Windows windows and native anchored popups

TODO

@@ -1192,7 +1193,6 @@ belong in README. This list is only the remaining engineering work.

Low Priority

• Window controls - resize, minimize (title already works)
  -- [ ] Multiple windows - Support multiple GPUI windows
• JS remount - render() plus bun --hot remounts the React tree on the same window
• React Refresh in the browser - bun run web keeps useState across saves
• React Refresh on desktop - bun --hot is the runtime, not the bundler, so it runs no Fast Refresh transform. Tracked as oven-sh/bun#40179
  diff --git a/README.md b/README.md
  index a80899e..b347cad 100644
  --- a/README.md
  +++ b/README.md
  @@ -415,6 +415,7 @@ terminal.
  | appName | string | Name inside the macOS Hide X and Quit X items. Defaults to title |
  | focus | boolean, default true | false opens the window behind the active app, like open -g |
  | show | boolean, default true | false opens the window hidden. Call activateWindow() to reveal it |
  +| anchoredPopup | object | Open a Windows renderer as a transparent native popup owned and positioned by another renderer |

Call it again after a save and it remounts the tree on the same window.

@@ -457,6 +458,46 @@ id, and one event map, so createRoot() throws if that renderer already has a
mounted root. Call unmount() on the first root before you create another;
render() already does that for you.

+### Native anchored popups on Windows
+
+Windows renderers share one GPUI application host, so a second renderer can be
+an owned popup instead of a second unrelated application window. The popup is
+composited with per-pixel alpha: draw the rounded surface in React and leave the
+window background transparent. Do not apply a Win32 region mask; region edges
+are binary and visibly stair-step on rounded corners.
+
+```tsx
+const parent = createRenderer()
+parent.init({ title: 'Library', width: 560, height: 420 })
+
+const popup = createRenderer()
+popup.init({

• width: 320,
• height: 240,
• focus: false,
• resizable: false,
• windowBackground: 'transparent',
• anchoredPopup: {
• parentWindowId: parent.getWindowId(),
• anchorX: 24,
• anchorY: 120,
• anchorWidth: 280,
• anchorHeight: 40,
• anchor: 'bottomLeft',
• gravity: 'bottomRight',
• offsetY: 6,
• constraintAdjustment: ['flipY', 'slideX', 'slideY'],
• grab: false,
• },
  +})
  +```

+The anchor rectangle is measured in the parent window's logical pixels. The
+native backend converts it to the parent monitor's scale, keeps the popup on
+screen, assigns the owner window, and waits for the transparent background
+before showing the first frame. Call popup.closeWindow() when the popover is
+dismissed; closing it does not stop the parent renderer.
+

Background launch

focus: false opens the window without taking focus. The app you were
@@ -2571,7 +2612,7 @@ The test renderer uses VisualTestAppContext with a TestDispatcher for determ

• Last window close quits the process
• Debug frame overlay (debugFrameOverlay / setDebugFrameOverlay)
• Canvas element
  -- [ ] Multiple windows
  +- [x] Multiple Windows windows, including owned anchored popups
• JS remount under bun --hot (render() keeps the native window)
• React Refresh during bun --hot (needs a Bun runtime transform)
• Hot reload of the native .node addon. bun run dev rebuilds and restarts. Native modules cannot unload.
  diff --git a/examples/anchored-popup.tsx b/examples/anchored-popup.tsx
  new file mode 100644
  index 0000000..a498031
  --- /dev/null
  +++ b/examples/anchored-popup.tsx
  @@ -0,0 +1,112 @@
  +import React from "react"
  +import {

• createRenderer,
• createRoot,
• flushSync,
  +} from "@gpuix/react"

+const main = createRenderer()
+main.init({

• title: "GPUIX anchored popup probe",
• width: 520,
• height: 320,
• focus: false,
  +})

+const mainRoot = createRoot(main)
+flushSync(() => {

• mainRoot.render(

•  style={{
  

•    width: "100%",
  

•    height: "100%",
  

•    backgroundColor: "#f4f4f6",
  

•    padding: 40,
  

•  }}
  

•  <text style={{ fontSize: 18, color: "#242428" }}>
  

•    Native popup owner
  

•  </text>
  

•  <div
  

•    style={{
  

•      position: "absolute",
  

•      left: 40,
  

•      top: 150,
  

•      width: 300,
  

•      height: 40,
  

•      borderRadius: 10,
  

•      backgroundColor: "#ffffff",
  

•      borderWidth: 1,
  

•      borderColor: "#d8d8dc",
  

•      paddingLeft: 14,
  

•      justifyContent: "center",
  

•    }}
  

•  >
  

•    <text style={{ color: "#35353a" }}>P1 · Anchored trigger</text>
  

•  </div>
  

• )
  +})

+const popup = createRenderer()
+popup.init({

• title: "GPUIX anchored popup",
• width: 320,
• height: 226,
• focus: false,
• transparent: true,
• windowBackground: "transparent",
• resizable: false,
• anchoredPopup: {
• parentWindowId: main.getWindowId(),
• anchorX: 40,
• anchorY: 150,
• anchorWidth: 300,
• anchorHeight: 40,
• anchor: "bottomLeft",
• gravity: "bottomRight",
• offsetY: 6,
• constraintAdjustment: ["flipY", "slideX", "slideY"],
• grab: false,
• },
  +})

+const popupRoot = createRoot(popup)
+flushSync(() => {

• popupRoot.render(

•  style={{
  

•    width: "100%",
  

•    height: "100%",
  

•    backgroundColor: "#ffffff",
  

•    borderRadius: 16,
  

•    borderWidth: 1,
  

•    borderColor: "#e1e1e5",
  

•    padding: 10,
  

•    gap: 3,
  

•  }}
  

•  {["P1 · First item", "P2 · Second item", "P3 · Third item", "P4 · Fourth item"].map(
  

•    (label, index) => (
  

•      <div
  

•        key={label}
  

•        style={{
  

•          height: 45,
  

•          borderRadius: 9,
  

•          backgroundColor: index === 0 ? "#f1f1f3" : "transparent",
  

•          paddingLeft: 12,
  

•          justifyContent: "center",
  

•        }}
  

•      >
  

•        <text style={{ color: "#303035" }}>{label}</text>
  

•      </div>
  

•    )
  

•  )}
  

• )
  +})

+if (process.env.GPUIX_PROBE_AUTOCLOSE === "1") {

• setTimeout(() => popup.closeWindow(), 250)
• setTimeout(() => main.closeWindow(), 1_500)
  +}
  diff --git a/packages/native/src/renderer.rs b/packages/native/src/renderer.rs
  index c7ff878..4faef95 100644
  --- a/packages/native/src/renderer.rs
  +++ b/packages/native/src/renderer.rs
  @@ -29,6 +29,11 @@ use std::collections::{HashMap, HashSet};
  use std::rc::Rc;
  #[cfg(any(target_os = "windows", target_os = "linux", target_os = "freebsd"))]
  use std::sync::mpsc::{sync_channel, RecvTimeoutError, SyncSender};
  +#[cfg(target_os = "windows")]
  +use std::sync::{
• atomic::{AtomicU64, Ordering},
• OnceLock,
  +};
  use std::sync::{Arc, Mutex};
  #[cfg(any(target_os = "windows", target_os = "linux", target_os = "freebsd"))]
  use std::time::Duration;
  @@ -134,9 +139,9 @@ thread_local! {
  /// ScrollHandle is Rc<RefCell<...>> so its methods (set_offset, offset,
  /// scroll_to_item) work without an App context.
  ///

• /// NOTE: This is a singleton — if multiple renderers/windows coexist,
• /// the last one to render wins. Acceptable for now (single-window only).
• /// TODO: Scope by renderer/window ID when multi-window support is added.

• /// Threaded desktop windows read their handles directly from GpuixView.
• /// These mirrors remain for embedded and test renderers that do not route
• /// commands through a specific window entity.
  static SCROLL_HANDLES: RefCell<HashMap<u64, gpui::ScrollHandle>> = RefCell::new(HashMap::new());
  static VIRTUAL_LIST_STATES: RefCell<HashMap<u64, gpui::ListState>> = RefCell::new(HashMap::new());
  /// Virtual-list scrolls queued for the next GpuixView::render, applied
  @@ -150,6 +155,13 @@ thread_local! {
  RefCell::new(HashMap::new());
  }

+#[cfg(target_os = "windows")]
+static NEXT_WINDOW_ID: AtomicU64 = AtomicU64::new(1);
+
+#[cfg(target_os = "windows")]
+static WINDOWS_UI_HOST: OnceLock<Mutex<Option<mpsc::UnboundedSender>>> =

• OnceLock::new();

/// Queue a virtual-list scroll for the next render. offset_in_item may be
/// negative: gpui then anchors the viewport top above the item, which is what
/// keeps a row pixel-stable while unmeasured rows are spliced in above it.
@@ -382,6 +394,20 @@ enum UiCommand {
response: SyncSender<std::result::Result<(), String>>,
},
Blur,

• CloseWindow,
  +}

+#[cfg(target_os = "windows")]
+enum WindowsHostCommand {

• OpenWindow {

•    window_id: u64,
  

•    options: WindowOptions,
  

•    tree: Arc<Mutex<RetainedTree>>,
  

•    event_callback: Option<EventCallback>,
  

•    selection: SharedSelection,
  

•    ui_commands: mpsc::UnboundedReceiver<UiCommand>,
  

•    response: SyncSender<std::result::Result<(), String>>,
  

• },
  }

#[cfg(any(target_os = "windows", target_os = "linux", target_os = "freebsd"))]
@@ -403,6 +429,7 @@ async fn run_ui_commands(
) {
while let Some(command) = commands.next().await {
let result = match command {

•        UiCommand::CloseWindow => break,
         UiCommand::Invalidate => refresh_ui_window(window, cx),
         UiCommand::ActivateWindow => window.update(cx, |_view, window, cx| {
             cx.activate(true);
  

@@ -449,87 +476,76 @@ async fn run_ui_commands(
UiCommand::ResetDebugFrameOverlayStats => window.update(cx, |_view, window, _cx| {
window.reset_debug_frame_overlay_stats();
}),

•        UiCommand::ScrollTo { id, x, y } => {
  

•            if !VIRTUAL_LIST_STATES.with(|cell| {
  

•                let states = cell.borrow();
  

•                let Some(state) = states.get(&id) else {
  

•                    return false;
  

•                };
  

•                state.set_offset_from_scrollbar(gpui::point(gpui::px(x), gpui::px(y)));
  

•                true
  

•            }) {
  

•                SCROLL_HANDLES.with(|cell| {
  

•                    if let Some(handle) = cell.borrow().get(&id) {
  

•                        handle.set_offset(gpui::point(gpui::px(x), gpui::px(y)));
  

•                    }
  

•                });
  

•        UiCommand::ScrollTo { id, x, y } => window.update(cx, move |view, window, cx| {
  

•            if let Some(entry) = view.virtual_lists.get(&id) {
  

•                entry
  

•                    .state
  

•                    .set_offset_from_scrollbar(gpui::point(gpui::px(x), gpui::px(y)));
  

•            } else if let Some(handle) = view.scroll_handles.get(&id) {
  

•                handle.set_offset(gpui::point(gpui::px(x), gpui::px(y)));
             }
  

•            refresh_ui_window(window, cx)
  

•        }
  

•            cx.notify();
  

•            window.refresh();
  

•        }),
         UiCommand::ScrollToItem { id, index, offset } => {
  

•            if !VIRTUAL_LIST_STATES.with(|cell| {
  

•                if !cell.borrow().contains_key(&id) {
  

•                    return false;
  

•            window.update(cx, move |view, window, cx| {
  

•                if view.virtual_lists.contains_key(&id) {
  

•                    queue_virtual_list_scroll(id, index, offset);
  

•                } else if let Some(handle) = view.scroll_handles.get(&id) {
  

•                    handle.scroll_to_item(index);
                 }
  

•                queue_virtual_list_scroll(id, index, offset);
  

•                true
  

•            }) {
  

•                SCROLL_HANDLES.with(|cell| {
  

•                    if let Some(handle) = cell.borrow().get(&id) {
  

•                        handle.scroll_to_item(index);
  

•                    }
  

•                });
  

•            }
  

•            refresh_ui_window(window, cx)
  

•                cx.notify();
  

•                window.refresh();
  

•            })
         }
         UiCommand::GetScrollOffset { id, response } => {
  

•            let offset = VIRTUAL_LIST_STATES
  

•                .with(|cell| {
  

•                    cell.borrow().get(&id).map(|state| {
  

•                        let offset = state.scroll_px_offset_for_scrollbar();
  

•            window.update(cx, move |view, _window, _cx| {
  

•                let offset = view
  

•                    .virtual_lists
  

•                    .get(&id)
  

•                    .map(|entry| {
  

•                        let offset = entry.state.scroll_px_offset_for_scrollbar();
                         [
                             f64::from(f32::from(offset.x)),
                             f64::from(f32::from(offset.y)),
                         ]
                     })
  

•                })
  

•                .or_else(|| {
  

•                    SCROLL_HANDLES.with(|cell| {
  

•                        cell.borrow().get(&id).map(|handle| {
  

•                    .or_else(|| {
  

•                        view.scroll_handles.get(&id).map(|handle| {
                             let offset = handle.offset();
                             [
                                 f64::from(f32::from(offset.x)),
                                 f64::from(f32::from(offset.y)),
                             ]
                         })
  

•                    })
  

•                });
  

•            response.send(offset).ok();
  

•            Ok(())
  

•                    });
  

•                response.send(offset).ok();
  

•            })
         }
         UiCommand::GetListScrollTop { id, response } => {
  

•            let top = VIRTUAL_LIST_STATES.with(|cell| {
  

•                cell.borrow().get(&id).map(|state| {
  

•                    let top = state.logical_scroll_top();
  

•            window.update(cx, move |view, _window, _cx| {
  

•                let top = view.virtual_lists.get(&id).map(|entry| {
  

•                    let top = entry.state.logical_scroll_top();
                     [
                         top.item_ix as f64,
                         f64::from(f32::from(top.offset_in_item)),
  

•                        f64::from(f32::from(state.viewport_bounds().size.height)),
  

•                        f64::from(f32::from(entry.state.viewport_bounds().size.height)),
                     ]
  

•                })
  

•            });
  

•            response.send(top).ok();
  

•            Ok(())
  

•                });
  

•                response.send(top).ok();
  

•            })
  

•        }
  

•        UiCommand::GetWindowSize { response } => {
  

•            window.update(cx, move |_view, window, _cx| {
  

•                let size = window.viewport_size();
  

•                response
  

•                    .send(WindowSize {
  

•                        width: f32::from(size.width) as f64,
  

•                        height: f32::from(size.height) as f64,
  

•                    })
  

•                    .ok();
  

•            })
         }
  

•        UiCommand::GetWindowSize { response } => window.update(cx, move |_view, window, _cx| {
  

•            let size = window.viewport_size();
  

•            response
  

•                .send(WindowSize {
  

•                    width: f32::from(size.width) as f64,
  

•                    height: f32::from(size.height) as f64,
  

•                })
  

•                .ok();
  

•        }),
         UiCommand::GetAutomationBounds { response } => {
             window.update(cx, move |_view, window, cx| {
                 cx.notify();
  

@@ -684,6 +700,12 @@ async fn run_ui_commands(
log::error!("Failed to handle GPUI UI command: {error:#}");
}
}

• #[cfg(target_os = "windows")]
• if let Err(error) = window.update(cx, |_view, window, _cx| window.remove_window()) {

•    log::error!("Failed to close the GPUI window: {error:#}");
  

• }
• #[cfg(any(target_os = "linux", target_os = "freebsd"))]
  cx.update(|cx| cx.quit());
  }

@@ -696,10 +718,117 @@ fn panic_message(payload: Box<dyn std::any::Any + Send>) -> String {
.unwrap_or_else(|| "unknown panic".to_string())
}

+#[cfg(target_os = "windows")]
+fn windows_ui_host_sender() -> Result<mpsc::UnboundedSender> {

• let host = WINDOWS_UI_HOST.get_or_init(|| Mutex::new(None));
• let mut stored = host.lock().unwrap();
• if let Some(sender) = stored.as_ref().filter(|sender| !sender.is_closed()) {

•    return Ok(sender.clone());
  

• }
• let (sender, commands) = mpsc::unbounded();
• std::thread::Builder::new()

•    .name("gpuix-ui".to_string())
  

•    .spawn(move || {
  

•        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
  

•            gpui_platform::application().run(move |cx| {
  

•                init_key_bindings(cx);
  

•                crate::custom_elements::input::init(cx);
  

•                cx.spawn(async move |cx| {
  

•                    run_windows_host(commands, cx).await;
  

•                })
  

•                .detach();
  

•            });
  

•        }));
  

•        if let Err(payload) = result {
  

•            log::error!("The GPUI UI thread panicked: {}", panic_message(payload));
  

•        }
  

•        if let Some(host) = WINDOWS_UI_HOST.get() {
  

•            host.lock().unwrap().take();
  

•        }
  

•    })
  

•    .map_err(|error| {
  

•        Error::from_reason(format!("Failed to spawn the GPUI UI thread: {error}"))
  

•    })?;
  

• *stored = Some(sender.clone());
• Ok(sender)
  +}

+#[cfg(target_os = "windows")]
+async fn run_windows_host(

• mut commands: mpsc::UnboundedReceiver,
• cx: &mut gpui::AsyncApp,
  +) {
• let mut windows = HashMap::<u64, gpui::WindowHandle>::new();
• while let Some(command) = commands.next().await {

•    match command {
  

•        WindowsHostCommand::OpenWindow {
  

•            window_id,
  

•            options,
  

•            tree,
  

•            event_callback,
  

•            selection,
  

•            ui_commands,
  

•            response,
  

•        } => {
  

•            let title = options.title.clone().unwrap_or_else(|| "GPUIX".to_string());
  

•            let activate = options.focus.unwrap_or(true);
  

•            let parent = options
  

•                .anchored_popup
  

•                .as_ref()
  

•                .and_then(|popup| raw_element_id(popup.parent_window_id).ok())
  

•                .and_then(|parent_id| windows.get(&parent_id).copied())
  

•                .map(gpui::AnyWindowHandle::from);
  

•            let opened = cx.update(|cx| {
  

•                let bounds = gpui::Bounds::centered(
  

•                    None,
  

•                    gpui::size(
  

•                        gpui::px(options.width.unwrap_or(800.0) as f32),
  

•                        gpui::px(options.height.unwrap_or(600.0) as f32),
  

•                    ),
  

•                    cx,
  

•                );
  

•                let mut window_options = to_gpui_window_options(&options, bounds);
  

•                configure_anchored_popup(&options, parent, &mut window_options)
  

•                    .map_err(anyhow::Error::msg)?;
  

•                cx.open_window(window_options, |_window, cx| {
  

•                    cx.new(|_| GpuixView::new(tree, event_callback, title, selection))
  

•                })
  

•            });
  

•            match opened {
  

•                Ok(window) => {
  

•                    windows.insert(window_id, window);
  

•                    cx.spawn(async move |cx| {
  

•                        run_ui_commands(ui_commands, window, cx).await;
  

•                    })
  

•                    .detach();
  

•                    if activate {
  

•                        cx.update(|cx| cx.activate(true));
  

•                    }
  

•                    response.send(Ok(())).ok();
  

•                }
  

•                Err(error) => {
  

•                    response
  

•                        .send(Err(format!("Failed to open the GPUI window: {error:#}")))
  

•                        .ok();
  

•                }
  

•            }
  

•        }
  

•    }
  

• }
  +}

/// The main GPUI renderer exposed to Node.js.
#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
#[napi]
pub struct GpuixRenderer {

• #[cfg(target_os = "windows")]
• window_id: u64,
  event_callback: Mutex<Option<Arc<ThreadsafeFunction>>>,
  tree: Arc<Mutex>,
  initialized: Arc<Mutex>,
  @@ -824,6 +953,8 @@ impl GpuixRenderer {
  pub fn new(event_callback: Option<ThreadsafeFunction>) -> Self {
  let _ = env_logger::try_init();
  Self {

•        #[cfg(target_os = "windows")]
  

•        window_id: NEXT_WINDOW_ID.fetch_add(1, Ordering::Relaxed),
         event_callback: Mutex::new(event_callback.map(Arc::new)),
         tree: Arc::new(Mutex::new(RetainedTree::new())),
         initialized: Arc::new(Mutex::new(false)),
  

@@ -833,6 +964,16 @@ impl GpuixRenderer {
}
}

• /// Stable ID used to parent another renderer's native popup window.
• #[napi]
• pub fn get_window_id(&self) -> f64 {

•    #[cfg(target_os = "windows")]
  

•    return self.window_id as f64;
  

•    #[cfg(not(target_os = "windows"))]
  

•    0.0
  

• }
• /// Initialize GPUI using the native event-loop architecture for this OS.
  #[napi]
  pub fn init(&self, options: Option) -> Result<()> {
  @@ -852,10 +993,42 @@ impl GpuixRenderer {
  #[cfg(target_os = "macos")]
  return self.init_macos(options);

•    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "freebsd"))]
  

•    #[cfg(target_os = "windows")]
  

•    return self.init_windows(options);
  

•    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
     return self.init_threaded(options);
  

  }

• #[cfg(target_os = "windows")]

• fn init_windows(&self, options: Option) -> Result<()> {

•    let options = options.unwrap_or_default();
  

•    if *self.initialized.lock().unwrap() {
  

•        return Err(Error::from_reason("Renderer is already initialized"));
  

•    }
  

•    let (command_sender, command_receiver) = mpsc::unbounded();
  

•    let (startup_sender, startup_receiver) = sync_channel(1);
  

•    windows_ui_host_sender()?
  

•        .unbounded_send(WindowsHostCommand::OpenWindow {
  

•            window_id: self.window_id,
  

•            options,
  

•            tree: self.tree.clone(),
  

•            event_callback: self.event_callback_for_view(),
  

•            selection: self.selection.clone(),
  

•            ui_commands: command_receiver,
  

•            response: startup_sender,
  

•        })
  

•        .map_err(|_| Error::from_reason("The GPUI UI thread is not running"))?;
  

•    recv_ui_response(startup_receiver, "the GPUI window initialization")?
  

•        .map_err(Error::from_reason)?;
  

•    *self.ui_commands.lock().unwrap() = Some(command_sender);
  

•    *self.initialized.lock().unwrap() = true;
  

•    self.event_callback.lock().unwrap().take();
  

•    Ok(())
  

• }

• #[cfg(target_os = "macos")]
  fn init_macos(&self, options: Option) -> Result<()> {
  let options = options.unwrap_or_default();
  @@ -964,7 +1137,7 @@ impl GpuixRenderer {
  Ok(())
  }

• #[cfg(any(target_os = "windows", target_os = "linux", target_os = "freebsd"))]

• #[cfg(any(target_os = "linux", target_os = "freebsd"))]
  fn init_threaded(&self, options: Option) -> Result<()> {
  let options = options.unwrap_or_default();
  if *self.initialized.lock().unwrap() {
  @@ -1434,6 +1607,26 @@ impl GpuixRenderer {
  ))
  }

• /// Close only this renderer's window. Other renderer windows keep running.

• #[napi]

• pub fn close_window(&self) -> Result<()> {

•    #[cfg(target_os = "macos")]
  

•    return update_window(|_view, window, _cx| window.remove_window());
  

•    #[cfg(any(target_os = "windows", target_os = "linux", target_os = "freebsd"))]
  

•    return self.send_ui_command(UiCommand::CloseWindow);
  

•    #[cfg(not(any(
  

•        target_os = "macos",
  

•        target_os = "windows",
  

•        target_os = "linux",
  

•        target_os = "freebsd"
  

•    )))]
  

•    Err(Error::from_reason(
  

•        "The production GPUIX renderer does not support this operating system",
  

•    ))
  

• }

• #[napi]
  pub fn set_window_title(&self, title: String) -> Result<()> {
  #[cfg(target_os = "macos")]
  @@ -5352,6 +5545,27 @@ pub struct DebugFrameOverlayStats {
  pub samples: f64,
  }

+#[derive(Debug, Clone)]
+#[cfg_attr(not(all(target_arch = "wasm32", target_os = "unknown")), napi(object))]
+pub struct AnchoredPopupOptions {

• /// getWindowId() from the renderer that owns the parent window.
• pub parent_window_id: f64,
• pub anchor_x: f64,
• pub anchor_y: f64,
• pub anchor_width: f64,
• pub anchor_height: f64,
• /// center, top, bottom, left, right, topLeft, bottomLeft,
• /// topRight, or bottomRight.
• pub anchor: Option,
• /// Uses the same values as anchor.
• pub gravity: Option,
• pub offset_x: Option,
• pub offset_y: Option,
• /// Any of flipX, flipY, slideX, slideY, resizeX, resizeY.
• pub constraint_adjustment: Option<Vec>,
• pub grab: Option,
  +}

#[derive(Debug, Clone)]
#[cfg_attr(not(all(target_arch = "wasm32", target_os = "unknown")), napi(object))]
pub struct WindowOptions {
@@ -5381,6 +5595,9 @@ pub struct WindowOptions {
/// Show the window when it opens. false opens it hidden; call
/// activateWindow() to reveal it. Ignored on Linux.
pub show: Option,

• /// Open this renderer as a native popup owned by another renderer window.
• /// Currently supported on Windows.
• pub anchored_popup: Option,
  }

impl Default for WindowOptions {
@@ -5401,10 +5618,102 @@ impl Default for WindowOptions {
traffic_light_y: None,
focus: Some(true),
show: Some(true),

•        anchored_popup: None,
     }
  

  }
  }

+#[cfg(target_os = "windows")]
+fn configure_anchored_popup(

• options: &WindowOptions,
• parent: Optiongpui::AnyWindowHandle,
• window_options: &mut gpui::WindowOptions,
  +) -> std::result::Result<(), String> {
• let Some(popup) = options.anchored_popup.as_ref() else {

•    return Ok(());
  

• };
• let parent = parent.ok_or_else(|| {

•    format!(
  

•        "Anchored popup parent window {} is not open",
  

•        popup.parent_window_id
  

•    )
  

• })?;
• let mut constraint_adjustment = gpui::popup::PopupConstraintAdjustment::empty();
• let adjustments: Vec<&str> = popup

•    .constraint_adjustment
  

•    .as_ref()
  

•    .map(|values| values.iter().map(String::as_str).collect())
  

•    .unwrap_or_else(|| vec!["flipX", "flipY", "slideX", "slideY"]);
  

• for adjustment in adjustments {

•    constraint_adjustment |= match adjustment {
  

•        "flipX" => gpui::popup::PopupConstraintAdjustment::FLIP_X,
  

•        "flipY" => gpui::popup::PopupConstraintAdjustment::FLIP_Y,
  

•        "slideX" => gpui::popup::PopupConstraintAdjustment::SLIDE_X,
  

•        "slideY" => gpui::popup::PopupConstraintAdjustment::SLIDE_Y,
  

•        "resizeX" => gpui::popup::PopupConstraintAdjustment::RESIZE_X,
  

•        "resizeY" => gpui::popup::PopupConstraintAdjustment::RESIZE_Y,
  

•        value => return Err(format!("Unknown popup constraint adjustment {value:?}")),
  

•    };
  

• }
• window_options.kind = gpui::WindowKind::AnchoredPopup(gpui::popup::PopupOptions {

•    parent,
  

•    anchor_rect: gpui::Bounds {
  

•        origin: gpui::point(
  

•            gpui::px(popup.anchor_x as f32),
  

•            gpui::px(popup.anchor_y as f32),
  

•        ),
  

•        size: gpui::size(
  

•            gpui::px(popup.anchor_width as f32),
  

•            gpui::px(popup.anchor_height as f32),
  

•        ),
  

•    },
  

•    anchor: parse_popup_anchor(popup.anchor.as_deref().unwrap_or("bottomLeft"))?,
  

•    gravity: parse_popup_gravity(popup.gravity.as_deref().unwrap_or("bottomRight"))?,
  

•    constraint_adjustment,
  

•    offset: gpui::point(
  

•        gpui::px(popup.offset_x.unwrap_or(0.0) as f32),
  

•        gpui::px(popup.offset_y.unwrap_or(0.0) as f32),
  

•    ),
  

•    grab: popup.grab.unwrap_or(false),
  

• });
• window_options.titlebar = None;
• Ok(())
  +}

+#[cfg(target_os = "windows")]
+fn parse_popup_anchor(value: &str) -> std::result::Result<gpui::popup::PopupAnchor, String> {

• use gpui::popup::PopupAnchor;
• match value {

•    "center" => Ok(PopupAnchor::Center),
  

•    "top" => Ok(PopupAnchor::Top),
  

•    "bottom" => Ok(PopupAnchor::Bottom),
  

•    "left" => Ok(PopupAnchor::Left),
  

•    "right" => Ok(PopupAnchor::Right),
  

•    "topLeft" => Ok(PopupAnchor::TopLeft),
  

•    "bottomLeft" => Ok(PopupAnchor::BottomLeft),
  

•    "topRight" => Ok(PopupAnchor::TopRight),
  

•    "bottomRight" => Ok(PopupAnchor::BottomRight),
  

•    _ => Err(format!("Unknown popup anchor {value:?}")),
  

• }
  +}

+#[cfg(target_os = "windows")]
+fn parse_popup_gravity(value: &str) -> std::result::Result<gpui::popup::PopupGravity, String> {

• use gpui::popup::PopupGravity;
• match value {

•    "center" => Ok(PopupGravity::Center),
  

•    "top" => Ok(PopupGravity::Top),
  

•    "bottom" => Ok(PopupGravity::Bottom),
  

•    "left" => Ok(PopupGravity::Left),
  

•    "right" => Ok(PopupGravity::Right),
  

•    "topLeft" => Ok(PopupGravity::TopLeft),
  

•    "bottomLeft" => Ok(PopupGravity::BottomLeft),
  

•    "topRight" => Ok(PopupGravity::TopRight),
  

•    "bottomRight" => Ok(PopupGravity::BottomRight),
  

•    _ => Err(format!("Unknown popup gravity {value:?}")),
  

• }
  +}

fn to_gpui_window_options(
options: &WindowOptions,
bounds: gpui::Boundsgpui::Pixels,
diff --git a/packages/react/src/types/host.ts b/packages/react/src/types/host.ts
index 41a634f..fbdf656 100644
--- a/packages/react/src/types/host.ts
+++ b/packages/react/src/types/host.ts
@@ -613,8 +613,12 @@ export interface NativeRenderer {
getWindowSize?(): { width: number; height: number }
getWindowInsets?(): NativeWindowInsets
setWindowTitle?(title: string): void

• /** Stable ID used as anchoredPopup.parentWindowId by another renderer. */
• getWindowId?(): number
  /** Bring the window forward and focus it. Reveals a show: false window. */
  activateWindow?(): void
• /** Close this renderer's window without stopping sibling renderer windows. */
• closeWindow?(): void
  setDebugFrameOverlay?(mode: DebugFrameOverlayMode): string
  getDebugFrameOverlay?(): string
  cycleDebugFrameOverlay?(): string
  diff --git a/zed b/zed
  index 8b94def..a11fd34 160000
  --- a/zed
  +++ b/zed
  @@ -1 +1 @@
  -Subproject commit 8b94defe56992b3ca4ffd4853ace741d8168111a
  +Subproject commit a11fd34736e48a89f2bb928372856edc5529005b

``

Layer 2 (GPUI / gpui_windows) is in the next comment. Both are the same committed state the branch links pointed at; I reviewed and applied them, the implementation came from the Codex-assisted workflow already disclosed in the issue body. Still happy to take the direction and split you prefer before any invited PR.

[Rizumu85]

Layer 2 of 2 — GPUI / gpui_windows, range 8b94defe56992b3ca4ffd4853ace741d8168111a..a11fd34736e48a89f2bb928372856edc5529005b on https://github.com/Rizumu85/zed/tree/gpuix-windows-anchored-popup — 4 files, +345/-17.

Two commits:

• 5b0145565a3957d12104cc0e7fda001923c104af implements the anchored popup windows.
• a11fd34736e48a89f2bb928372856edc5529005b makes WS_EX_NOACTIVATE follow WindowOptions.focus instead of the popup grab flag.

Also attached permanently as gpui-zed-windows-anchored-popup.patch:
https://github.com/Rizumu85/gpuix/releases/tag/patches-2026-09-13

GPUI diff (4 files, 490 lines)

``diff
diff --git a/README.md b/README.md
index 24840ee..c2ea73b 100644
--- a/README.md
+++ b/README.md
@@ -49,3 +49,5 @@ Zed is developed by Zed Industries, Inc., a for-profit company.
If you’d like to financially support the project, you can do so via GitHub Sponsors.
Sponsorships go directly to Zed Industries and are used as general company revenue.
There are no perks or entitlements associated with sponsorship.
+> [!IMPORTANT]
+> Remove this line to confirm you've reviewed this PR before submitting.
diff --git a/crates/gpui/examples/anchored_popup.rs b/crates/gpui/examples/anchored_popup.rs
new file mode 100644
index 0000000..a8e1f75
--- /dev/null
+++ b/crates/gpui/examples/anchored_popup.rs
@@ -0,0 +1,115 @@
+use gpui::{

• AnyWindowHandle, App, Bounds, Context, Window, WindowBounds, WindowKind, WindowOptions, div,
• point, popup::PopupAnchor, popup::PopupConstraintAdjustment, popup::PopupGravity,
• popup::PopupOptions, prelude::*, px, rgb, size,
  +};
  +use gpui_platform::application;

+const ANCHOR_BOUNDS: Boundsgpui::Pixels = Bounds {

• origin: point(px(36.0), px(176.0)),
• size: size(px(220.0), px(36.0)),
  +};

+struct ParentView;
+
+impl Render for ParentView {

• fn render(&mut self, _window: &mut Window, _cx: &mut Context) -> impl IntoElement {

•    div().size_full().bg(rgb(0xf1f1f4)).child(
  

•        div()
  

•            .absolute()
  

•            .left(ANCHOR_BOUNDS.origin.x)
  

•            .top(ANCHOR_BOUNDS.origin.y)
  

•            .w(ANCHOR_BOUNDS.size.width)
  

•            .h(ANCHOR_BOUNDS.size.height)
  

•            .flex()
  

•            .items_center()
  

•            .px_3()
  

•            .rounded_md()
  

•            .bg(rgb(0xffffff))
  

•            .border_1()
  

•            .border_color(rgb(0xd8d8dc))
  

•            .child("Anchored popup"),
  

•    )
  

• }
  +}

+struct PopupView;
+
+impl Render for PopupView {

• fn render(&mut self, _window: &mut Window, _cx: &mut Context) -> impl IntoElement {

•    div()
  

•        .size_full()
  

•        .p_2()
  

•        .flex()
  

•        .flex_col()
  

•        .gap_1()
  

•        .rounded_xl()
  

•        .bg(rgb(0xffffff))
  

•        .border_1()
  

•        .border_color(rgb(0xe4e4e8))
  

•        .child(
  

•            div()
  

•                .px_2()
  

•                .py_1()
  

•                .rounded_md()
  

•                .bg(rgb(0xf2f2f4))
  

•                .child("P1 · First item"),
  

•        )
  

•        .child(div().px_2().py_1().child("P2 · Second item"))
  

•        .child(div().px_2().py_1().child("P3 · Third item"))
  

•        .child(div().px_2().py_1().child("P4 · Fourth item"))
  

• }
  +}

+fn open_popup(parent: AnyWindowHandle, cx: &mut App) -> anyhow::Result<()> {

• cx.open_window(

•    WindowOptions {
  

•        titlebar: None,
  

•        window_bounds: Some(WindowBounds::Windowed(Bounds {
  

•            origin: point(px(0.0), px(0.0)),
  

•            size: size(px(260.0), px(204.0)),
  

•        })),
  

•        kind: WindowKind::AnchoredPopup(PopupOptions {
  

•            parent,
  

•            anchor_rect: ANCHOR_BOUNDS,
  

•            anchor: PopupAnchor::BottomLeft,
  

•            gravity: PopupGravity::BottomRight,
  

•            constraint_adjustment: PopupConstraintAdjustment::SLIDE_X
  

•                | PopupConstraintAdjustment::FLIP_Y,
  

•            offset: point(px(0.0), px(6.0)),
  

•            grab: false,
  

•        }),
  

•        focus: false,
  

•        window_background: gpui::WindowBackgroundAppearance::Transparent,
  

•        ..Default::default()
  

•    },
  

•    |_, cx| cx.new(|_| PopupView),
  

• )?;
• Ok(())
  +}

+fn main() {

• application().run(|cx: &mut App| {

•    let parent = cx
  

•        .open_window(
  

•            WindowOptions {
  

•                titlebar: Some(gpui::TitlebarOptions {
  

•                    title: Some("GPUI Windows Popup Probe".into()),
  

•                    ..Default::default()
  

•                }),
  

•                window_bounds: Some(WindowBounds::Windowed(Bounds {
  

•                    origin: point(px(240.0), px(160.0)),
  

•                    size: size(px(420.0), px(260.0)),
  

•                })),
  

•                focus: false,
  

•                ..Default::default()
  

•            },
  

•            |_, cx| cx.new(|_| ParentView),
  

•        )
  

•        .expect("opening parent probe window");
  

•    if let Err(error) = open_popup(parent.into(), cx) {
  

•        eprintln!("[popup-probe] {error:#}");
  

•    }
  

• });
  +}
  diff --git a/crates/gpui_windows/src/platform.rs b/crates/gpui_windows/src/platform.rs
  index 9147ce5..eaf24bf 100644
  --- a/crates/gpui_windows/src/platform.rs
  +++ b/crates/gpui_windows/src/platform.rs
  @@ -221,6 +221,15 @@ impl WindowsPlatform {
  .and_then(|hwnd| window_from_hwnd(hwnd.as_raw()))
  }

• fn hwnd_for_window(&self, handle: AnyWindowHandle) -> Option {

•    self.raw_window_handles.read().iter().find_map(|entry| {
  

•        let hwnd = entry.as_raw();
  

•        window_from_hwnd(hwnd)
  

•            .filter(|window| window.handle == handle)
  

•            .map(|_| hwnd)
  

•    })
  

• }

• #[inline]
  fn post_message(&self, message: u32, wparam: WPARAM, lparam: LPARAM) {
  self.raw_window_handles
  @@ -576,7 +585,15 @@ impl Platform for WindowsPlatform {
  handle: AnyWindowHandle,
  options: WindowParams,
  ) -> Result<Box> {

•    let window = WindowsWindow::new(handle, options, self.generate_creation_info())?;
  

•    let parent_hwnd = match &options.kind {
  

•        WindowKind::AnchoredPopup(options) => Some(
  

•            self.hwnd_for_window(options.parent)
  

•                .context("anchored popup parent window is not open")?,
  

•        ),
  

•        _ => None,
  

•    };
  

•    let window =
  

•        WindowsWindow::new(handle, options, self.generate_creation_info(), parent_hwnd)?;
     let handle = window.get_raw_handle();
     self.raw_window_handles.write().push(handle.into());
  

diff --git a/crates/gpui_windows/src/window.rs b/crates/gpui_windows/src/window.rs
index 1a942ec..d682bbc 100644
--- a/crates/gpui_windows/src/window.rs
+++ b/crates/gpui_windows/src/window.rs
@@ -88,6 +88,7 @@ pub struct WindowsWindowState {
initial_placement: Cell<Option>,
hwnd: HWND,
pub(crate) a11y: RefCell<Option>,

• show_after_background_update: Cell,
  }

pub(crate) struct WindowsWindowInner {
@@ -120,6 +121,7 @@ impl WindowsWindowState {
disable_direct_composition: bool,
invalidate_devices: Arc,
draw_coordinator: Rc,

•    show_after_background_update: bool,
  

  ) -> Result {
  let scale_factor = {
  let monitor_dpi = unsafe { GetDpiForWindow(hwnd) } as f32;
  @@ -186,6 +188,7 @@ impl WindowsWindowState {
  draw_coordinator,
  direct_manipulation,
  a11y: RefCell::new(None),

•        show_after_background_update: Cell::new(show_after_background_update),
     })
  

  }

@@ -262,6 +265,7 @@ impl WindowsWindowInner {
context.disable_direct_composition,
context.invalidate_devices.clone(),
context.draw_coordinator.clone(),

•        context.show_after_background_update,
     )?;
  
     Ok(Rc::new(Self {
  

@@ -411,6 +415,7 @@ struct WindowCreateContext {
invalidate_devices: Arc,
draw_coordinator: Rc,
parent_hwnd: Option,

• show_after_background_update: bool,
  }

impl WindowsWindow {
@@ -418,12 +423,12 @@ impl WindowsWindow {
handle: AnyWindowHandle,
params: WindowParams,
creation_info: WindowCreationInfo,

•    anchored_popup_parent: Option<HWND>,
  

  ) -> Result {

•    // Native popups are not implemented on Windows yet. Rejecting lets callers fall back to
  

•    // gpui's in-window popovers.
  

•    if let WindowKind::AnchoredPopup(_) = params.kind {
  

•        return Err(popup::PopupNotSupportedError.into());
  

•    }
  

•    let anchored_popup = match &params.kind {
  

•        WindowKind::AnchoredPopup(options) => Some(options.clone()),
  

•        _ => None,
  

•    };
  
     let WindowCreationInfo {
         icon,
  

@@ -440,7 +445,12 @@ impl WindowsWindow {
draw_coordinator,
} = creation_info;
register_window_class(icon);

•    let parent_hwnd = if params.kind == WindowKind::Dialog {
  

•    let parent_hwnd = if anchored_popup.is_some() {
  

•        Some(
  

•            anchored_popup_parent
  

•                .context("anchored popup parent window handle is unavailable")?,
  

•        )
  

•    } else if params.kind == WindowKind::Dialog {
         let parent_window = unsafe { GetActiveWindow() };
         if parent_window.is_invalid() {
             None
  

@@ -468,7 +478,13 @@ impl WindowsWindow {
.unwrap_or(""),
);

•    let (mut dwexstyle, dwstyle) = if params.kind == WindowKind::PopUp {
  

•    let (mut dwexstyle, dwstyle) = if anchored_popup.is_some() {
  

•        let mut extended_style = WS_EX_TOOLWINDOW;
  

•        if !params.focus {
  

•            extended_style |= WS_EX_NOACTIVATE;
  

•        }
  

•        (extended_style, WS_POPUP)
  

•    } else if params.kind == WindowKind::PopUp {
         (WS_EX_TOOLWINDOW | WS_EX_TOPMOST, WINDOW_STYLE(0x0))
     } else {
         let mut dwstyle = WS_SYSMENU;
  

@@ -494,13 +510,23 @@ impl WindowsWindow {
}

     let hinstance = get_module_handle();

•    let display = if let Some(display_id) = params.display_id {
  

•        WindowsDisplay::new(display_id)
  

•    } else {
  

•        None
  

•    }
  

•    .or_else(WindowsDisplay::primary_monitor)
  

•    .context("failed to find any monitor")?;
  

•    let display = parent_hwnd
  

•        .filter(|_| anchored_popup.is_some())
  

•        .and_then(|parent_hwnd| {
  

•            let monitor = unsafe { MonitorFromWindow(parent_hwnd, MONITOR_DEFAULTTONEAREST) };
  

•            (!monitor.is_invalid())
  

•                .then(|| WindowsDisplay::new(WindowsDisplay::display_id_for_monitor(monitor)))?
  

•        })
  

•        .or_else(|| params.display_id.and_then(WindowsDisplay::new))
  

•        .or_else(WindowsDisplay::primary_monitor)
  

•        .context("failed to find any monitor")?;
  

•    let placement_bounds =
  

•        if let (Some(options), Some(parent_hwnd)) = (anchored_popup.as_ref(), parent_hwnd) {
  

•            resolve_anchored_popup_bounds(parent_hwnd, display, options, params.bounds)?
  

•        } else {
  

•            params.bounds
  

•        };
  

•    let show_after_background_update = anchored_popup.is_some() && params.show;
     let appearance = system_appearance().unwrap_or_default();
     let mut context = WindowCreateContext {
         inner: None,
  

@@ -524,6 +550,7 @@ impl WindowsWindow {
invalidate_devices,
draw_coordinator,
parent_hwnd,

•        show_after_background_update,
     };
     let creation_result = unsafe {
         CreateWindowExW(
  

@@ -553,8 +580,8 @@ impl WindowsWindow {
configure_dwm_dark_mode(hwnd, appearance);
this.state.border_offset.update(hwnd)?;
let placement =

•        retrieve_window_placement(hwnd, display, params.bounds, &this.state.border_offset)?;
  

•    if params.show {
  

•        retrieve_window_placement(hwnd, display, placement_bounds, &this.state.border_offset)?;
  

•    if params.show && !show_after_background_update {
         let mut placement = placement;
         if !params.focus {
             placement.showCmd = SW_SHOWNOACTIVATE.0 as u32;
  

@@ -895,6 +922,10 @@ impl PlatformWindow for WindowsWindow {
dwm_set_window_composition_attribute(hwnd, 4);
}
}
+

•    if self.state.show_after_background_update.replace(false) {
  

•        self.0.set_window_placement().log_err();
  

•    }
  

  }

  fn minimize(&self) {
  @@ -1472,6 +1503,169 @@ fn register_drag_drop(window: &Rc) -> Result<()> {
  Ok(())
  }

+fn resolve_anchored_popup_bounds(

• parent_hwnd: HWND,
• display: WindowsDisplay,
• options: &popup::PopupOptions,
• requested_bounds: Bounds,
  +) -> Result<Bounds> {
• let parent_scale_factor =

•    unsafe { GetDpiForWindow(parent_hwnd) } as f32 / USER_DEFAULT_SCREEN_DPI as f32;
  

• let popup_scale_factor = display.scale_factor();
• let mut parent_client_origin = POINT::default();
• unsafe { ClientToScreen(parent_hwnd, &mut parent_client_origin) }

•    .ok()
  

•    .context("failed to locate anchored popup parent client area")?;
  

• let anchor_left =

•    parent_client_origin.x as f32 + options.anchor_rect.origin.x.as_f32() * parent_scale_factor;
  

• let anchor_top =

•    parent_client_origin.y as f32 + options.anchor_rect.origin.y.as_f32() * parent_scale_factor;
  

• let anchor_width = options.anchor_rect.size.width.as_f32() * parent_scale_factor;
• let anchor_height = options.anchor_rect.size.height.as_f32() * parent_scale_factor;
• let (anchor_x_factor, anchor_y_factor) = popup_anchor_factors(options.anchor);
• let (gravity_x_factor, gravity_y_factor) = popup_gravity_factors(options.gravity);
• let offset_x = options.offset.x.as_f32() * parent_scale_factor;
• let offset_y = options.offset.y.as_f32() * parent_scale_factor;
• let mut popup_width = requested_bounds.size.width.as_f32() * popup_scale_factor;
• let mut popup_height = requested_bounds.size.height.as_f32() * popup_scale_factor;
• let mut popup_left =

•    anchor_left + anchor_width * anchor_x_factor + popup_width * gravity_x_factor + offset_x;
  

• let mut popup_top =

•    anchor_top + anchor_height * anchor_y_factor + popup_height * gravity_y_factor + offset_y;
  

• let visible_bounds = display

•    .visible_bounds()
  

•    .to_device_pixels(popup_scale_factor);
  

• let visible_left = visible_bounds.left().0 as f32;
• let visible_top = visible_bounds.top().0 as f32;
• let visible_right = visible_bounds.right().0 as f32;
• let visible_bottom = visible_bounds.bottom().0 as f32;
• if options

•    .constraint_adjustment
  

•    .contains(popup::PopupConstraintAdjustment::FLIP_X)
  

• {

•    let flipped_left = anchor_left
  

•        + anchor_width * (1.0 - anchor_x_factor)
  

•        + popup_width * (-1.0 - gravity_x_factor)
  

•        + offset_x;
  

•    if popup_axis_overflow(flipped_left, popup_width, visible_left, visible_right)
  

•        < popup_axis_overflow(popup_left, popup_width, visible_left, visible_right)
  

•    {
  

•        popup_left = flipped_left;
  

•    }
  

• }
• if options

•    .constraint_adjustment
  

•    .contains(popup::PopupConstraintAdjustment::FLIP_Y)
  

• {

•    let flipped_top = anchor_top
  

•        + anchor_height * (1.0 - anchor_y_factor)
  

•        + popup_height * (-1.0 - gravity_y_factor)
  

•        + offset_y;
  

•    if popup_axis_overflow(flipped_top, popup_height, visible_top, visible_bottom)
  

•        < popup_axis_overflow(popup_top, popup_height, visible_top, visible_bottom)
  

•    {
  

•        popup_top = flipped_top;
  

•    }
  

• }
• if options

•    .constraint_adjustment
  

•    .contains(popup::PopupConstraintAdjustment::RESIZE_X)
  

•    && popup_axis_overflow(popup_left, popup_width, visible_left, visible_right) > 0.0
  

• {

•    let resized_left = popup_left.max(visible_left);
  

•    let resized_right = (popup_left + popup_width).min(visible_right);
  

•    if resized_right > resized_left {
  

•        popup_left = resized_left;
  

•        popup_width = resized_right - resized_left;
  

•    }
  

• }
• if options

•    .constraint_adjustment
  

•    .contains(popup::PopupConstraintAdjustment::RESIZE_Y)
  

•    && popup_axis_overflow(popup_top, popup_height, visible_top, visible_bottom) > 0.0
  

• {

•    let resized_top = popup_top.max(visible_top);
  

•    let resized_bottom = (popup_top + popup_height).min(visible_bottom);
  

•    if resized_bottom > resized_top {
  

•        popup_top = resized_top;
  

•        popup_height = resized_bottom - resized_top;
  

•    }
  

• }
• if options

•    .constraint_adjustment
  

•    .contains(popup::PopupConstraintAdjustment::SLIDE_X)
  

• {

•    popup_left = clamp_popup_axis(popup_left, popup_width, visible_left, visible_right);
  

• }
• if options

•    .constraint_adjustment
  

•    .contains(popup::PopupConstraintAdjustment::SLIDE_Y)
  

• {

•    popup_top = clamp_popup_axis(popup_top, popup_height, visible_top, visible_bottom);
  

• }
• Ok(Bounds {

•    origin: point(
  

•        px(popup_left / popup_scale_factor),
  

•        px(popup_top / popup_scale_factor),
  

•    ),
  

•    size: size(
  

•        px(popup_width / popup_scale_factor),
  

•        px(popup_height / popup_scale_factor),
  

•    ),
  

• })
  +}

+fn popup_anchor_factors(anchor: popup::PopupAnchor) -> (f32, f32) {

• use popup::PopupAnchor::*;
• match anchor {

•    Center => (0.5, 0.5),
  

•    Top => (0.5, 0.0),
  

•    Bottom => (0.5, 1.0),
  

•    Left => (0.0, 0.5),
  

•    Right => (1.0, 0.5),
  

•    TopLeft => (0.0, 0.0),
  

•    BottomLeft => (0.0, 1.0),
  

•    TopRight => (1.0, 0.0),
  

•    BottomRight => (1.0, 1.0),
  

• }
  +}

+fn popup_gravity_factors(gravity: popup::PopupGravity) -> (f32, f32) {

• use popup::PopupGravity::*;
• match gravity {

•    Center => (-0.5, -0.5),
  

•    Top => (-0.5, -1.0),
  

•    Bottom => (-0.5, 0.0),
  

•    Left => (-1.0, -0.5),
  

•    Right => (0.0, -0.5),
  

•    TopLeft => (-1.0, -1.0),
  

•    BottomLeft => (-1.0, 0.0),
  

•    TopRight => (0.0, -1.0),
  

•    BottomRight => (0.0, 0.0),
  

• }
  +}

+fn popup_axis_overflow(origin: f32, size: f32, minimum: f32, maximum: f32) -> f32 {

• (minimum - origin).max(0.0) + (origin + size - maximum).max(0.0)
  +}

+fn clamp_popup_axis(origin: f32, size: f32, minimum: f32, maximum: f32) -> f32 {

• if size >= maximum - minimum {

•    minimum
  

• } else {

•    origin.clamp(minimum, maximum - size)
  

• }
  +}

fn calculate_window_rect(bounds: Bounds, border_offset: &WindowBorderOffset) -> RECT {
// NOTE:
// The reason we're not using AdjustWindowRectEx() here is

``

One note for the fork's own bookkeeping, not a request: the GPUIX side sits on 0.5.1 because that is what the downstream app ships, so the branch pins the zed submodule at a11fd34 rather than at gpuix head. If the direction fits, rebasing both layers onto current main is the first thing I would do.