diff --git a/Cargo.lock b/Cargo.lock
index 79662f089..e7adf72bf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4489,6 +4489,7 @@ dependencies = [
 name = "snowcap-api"
 version = "0.1.0"
 dependencies = [
+ "bitflags 2.10.0",
  "from_variants",
  "futures",
  "hyper-util",
diff --git a/api/lua/pinnacle-api-dev-1.rockspec b/api/lua/pinnacle-api-dev-1.rockspec
index 3ad109169..dad584921 100644
--- a/api/lua/pinnacle-api-dev-1.rockspec
+++ b/api/lua/pinnacle-api-dev-1.rockspec
@@ -50,6 +50,7 @@ build = {
         ["pinnacle.snowcap.snowcap.widget.operation"] = "pinnacle/snowcap/snowcap/widget/operation.lua",
         ["pinnacle.snowcap.snowcap.layer"] = "pinnacle/snowcap/snowcap/layer.lua",
         ["pinnacle.snowcap.snowcap.decoration"] = "pinnacle/snowcap/snowcap/decoration.lua",
+        ["pinnacle.snowcap.snowcap.popup"] = "pinnacle/snowcap/snowcap/popup.lua",
         ["pinnacle.snowcap.snowcap.util"] = "pinnacle/snowcap/snowcap/util.lua",
         ["pinnacle.snowcap.snowcap.log"] = "pinnacle/snowcap/snowcap/log.lua",
     },
diff --git a/snowcap/api/lua/snowcap-api-dev-1.rockspec b/snowcap/api/lua/snowcap-api-dev-1.rockspec
index dae013f51..a619de01d 100644
--- a/snowcap/api/lua/snowcap-api-dev-1.rockspec
+++ b/snowcap/api/lua/snowcap-api-dev-1.rockspec
@@ -28,6 +28,7 @@ build = {
         ["snowcap.widget.operation"] = "snowcap/widget/operation.lua",
         ["snowcap.layer"] = "snowcap/layer.lua",
         ["snowcap.decoration"] = "snowcap/decoration.lua",
+        ["snowcap.popup"] = "snowcap/popup.lua",
         ["snowcap.util"] = "snowcap/util.lua",
         ["snowcap.log"] = "snowcap/log.lua",
     },
diff --git a/snowcap/api/lua/snowcap/grpc/defs.lua b/snowcap/api/lua/snowcap/grpc/defs.lua
index 394785a07..aab623a75 100644
--- a/snowcap/api/lua/snowcap/grpc/defs.lua
+++ b/snowcap/api/lua/snowcap/grpc/defs.lua
@@ -681,6 +681,34 @@ local snowcap_layer_v1_Layer = {
     LAYER_OVERLAY = 4,
 }
 
+---@enum snowcap.popup.v1.Anchor
+local snowcap_popup_v1_Anchor = {
+    ANCHOR_UNSPECIFIED = 0,
+    ANCHOR_TOP = 1,
+    ANCHOR_BOTTOM = 2,
+    ANCHOR_LEFT = 3,
+    ANCHOR_RIGHT = 4,
+    ANCHOR_TOP_LEFT = 5,
+    ANCHOR_TOP_RIGHT = 6,
+    ANCHOR_BOTTOM_LEFT = 7,
+    ANCHOR_BOTTOM_RIGHT = 8,
+    ANCHOR_NONE = 9,
+}
+
+---@enum snowcap.popup.v1.Gravity
+local snowcap_popup_v1_Gravity = {
+    GRAVITY_UNSPECIFIED = 0,
+    GRAVITY_TOP = 1,
+    GRAVITY_BOTTOM = 2,
+    GRAVITY_LEFT = 3,
+    GRAVITY_RIGHT = 4,
+    GRAVITY_TOP_LEFT = 5,
+    GRAVITY_TOP_RIGHT = 6,
+    GRAVITY_BOTTOM_LEFT = 7,
+    GRAVITY_BOTTOM_RIGHT = 8,
+    GRAVITY_NONE = 9,
+}
+
 
 ---@alias google.protobuf.Empty nil
 
@@ -849,6 +877,7 @@ local snowcap_layer_v1_Layer = {
 ---@field clip boolean?
 ---@field child snowcap.widget.v1.WidgetDef?
 ---@field style snowcap.widget.v1.Container.Style?
+---@field id string?
 
 ---@class snowcap.widget.v1.Container.Style
 ---@field text_color snowcap.widget.v1.Color?
@@ -995,6 +1024,7 @@ local snowcap_layer_v1_Layer = {
 ---@class snowcap.widget.v1.GetWidgetEventsRequest
 ---@field layer_id integer?
 ---@field decoration_id integer?
+---@field popup_id integer?
 
 ---@class snowcap.widget.v1.WidgetEvent
 ---@field widget_id integer?
@@ -1112,7 +1142,8 @@ local snowcap_layer_v1_Layer = {
 ---@field super boolean?
 
 ---@class snowcap.input.v1.KeyboardKeyRequest
----@field id integer?
+---@field layer_id integer?
+---@field popup_id integer?
 
 ---@class snowcap.input.v1.KeyboardKeyResponse
 ---@field key integer?
@@ -1277,6 +1308,71 @@ local snowcap_layer_v1_Layer = {
 
 ---@class snowcap.layer.v1.ViewResponse
 
+---@class snowcap.popup.v1.Offset
+---@field x number?
+---@field y number?
+
+---@class snowcap.popup.v1.Rectangle
+---@field x number?
+---@field y number?
+---@field width number?
+---@field height number?
+
+---@class snowcap.popup.v1.ConstraintsAdjust
+---@field none boolean?
+---@field slide_x boolean?
+---@field slide_y boolean?
+---@field flip_x boolean?
+---@field flip_y boolean?
+---@field resize_x boolean?
+---@field resize_y boolean?
+
+---@class snowcap.popup.v1.Position
+---@field at_cursor google.protobuf.Empty?
+---@field absolute snowcap.popup.v1.Rectangle?
+---@field at_widget string?
+
+---@class snowcap.popup.v1.NewPopupRequest
+---@field widget_def snowcap.widget.v1.WidgetDef?
+---@field layer_id integer?
+---@field deco_id integer?
+---@field popup_id integer?
+---@field position snowcap.popup.v1.Position?
+---@field anchor snowcap.popup.v1.Anchor?
+---@field gravity snowcap.popup.v1.Gravity?
+---@field offset snowcap.popup.v1.Offset?
+---@field constraints_adjust snowcap.popup.v1.ConstraintsAdjust?
+---@field no_grab boolean?
+---@field no_replace boolean?
+
+---@class snowcap.popup.v1.NewPopupResponse
+---@field popup_id integer?
+
+---@class snowcap.popup.v1.CloseRequest
+---@field popup_id integer?
+
+---@class snowcap.popup.v1.OperatePopupRequest
+---@field popup_id integer?
+---@field operation snowcap.operation.v1.Operation?
+
+---@class snowcap.popup.v1.OperatePopupResponse
+
+---@class snowcap.popup.v1.UpdatePopupRequest
+---@field popup_id integer?
+---@field widget_def snowcap.widget.v1.WidgetDef?
+---@field position snowcap.popup.v1.Position?
+---@field anchor snowcap.popup.v1.Anchor?
+---@field gravity snowcap.popup.v1.Gravity?
+---@field offset snowcap.popup.v1.Offset?
+---@field constraints_adjust snowcap.popup.v1.ConstraintsAdjust?
+
+---@class snowcap.popup.v1.UpdatePopupResponse
+
+---@class snowcap.popup.v1.ViewRequest
+---@field popup_id integer?
+
+---@class snowcap.popup.v1.ViewResponse
+
 ---@class snowcap.v0alpha1.Nothing
 
 ---@class snowcap.v1.Nothing
@@ -1402,6 +1498,21 @@ snowcap.layer.v1.UpdateLayerRequest = {}
 snowcap.layer.v1.UpdateLayerResponse = {}
 snowcap.layer.v1.ViewRequest = {}
 snowcap.layer.v1.ViewResponse = {}
+snowcap.popup = {}
+snowcap.popup.v1 = {}
+snowcap.popup.v1.Offset = {}
+snowcap.popup.v1.Rectangle = {}
+snowcap.popup.v1.ConstraintsAdjust = {}
+snowcap.popup.v1.Position = {}
+snowcap.popup.v1.NewPopupRequest = {}
+snowcap.popup.v1.NewPopupResponse = {}
+snowcap.popup.v1.CloseRequest = {}
+snowcap.popup.v1.OperatePopupRequest = {}
+snowcap.popup.v1.OperatePopupResponse = {}
+snowcap.popup.v1.UpdatePopupRequest = {}
+snowcap.popup.v1.UpdatePopupResponse = {}
+snowcap.popup.v1.ViewRequest = {}
+snowcap.popup.v1.ViewResponse = {}
 snowcap.v0alpha1 = {}
 snowcap.v0alpha1.Nothing = {}
 snowcap.v1 = {}
@@ -1424,6 +1535,8 @@ snowcap.layer.v0alpha1.Layer = snowcap_layer_v0alpha1_Layer
 snowcap.layer.v1.Anchor = snowcap_layer_v1_Anchor
 snowcap.layer.v1.KeyboardInteractivity = snowcap_layer_v1_KeyboardInteractivity
 snowcap.layer.v1.Layer = snowcap_layer_v1_Layer
+snowcap.popup.v1.Anchor = snowcap_popup_v1_Anchor
+snowcap.popup.v1.Gravity = snowcap_popup_v1_Gravity
 
 snowcap.widget.v1.WidgetService = {}
 snowcap.widget.v1.WidgetService.GetWidgetEvents = {}
@@ -1730,6 +1843,92 @@ snowcap.layer.v1.LayerService.RequestView.response = ".snowcap.layer.v1.ViewResp
 function Client:snowcap_layer_v1_LayerService_RequestView(data)
     return self:unary_request(snowcap.layer.v1.LayerService.RequestView, data)
 end
+snowcap.popup.v1.PopupService = {}
+snowcap.popup.v1.PopupService.NewPopup = {}
+snowcap.popup.v1.PopupService.NewPopup.service = "snowcap.popup.v1.PopupService"
+snowcap.popup.v1.PopupService.NewPopup.method = "NewPopup"
+snowcap.popup.v1.PopupService.NewPopup.request = ".snowcap.popup.v1.NewPopupRequest"
+snowcap.popup.v1.PopupService.NewPopup.response = ".snowcap.popup.v1.NewPopupResponse"
+
+---Performs a unary request.
+---
+---@nodiscard
+---
+---@param data snowcap.popup.v1.NewPopupRequest
+---
+---@return snowcap.popup.v1.NewPopupResponse | nil response
+---@return string | nil error An error string, if any
+function Client:snowcap_popup_v1_PopupService_NewPopup(data)
+    return self:unary_request(snowcap.popup.v1.PopupService.NewPopup, data)
+end
+snowcap.popup.v1.PopupService.Close = {}
+snowcap.popup.v1.PopupService.Close.service = "snowcap.popup.v1.PopupService"
+snowcap.popup.v1.PopupService.Close.method = "Close"
+snowcap.popup.v1.PopupService.Close.request = ".snowcap.popup.v1.CloseRequest"
+snowcap.popup.v1.PopupService.Close.response = ".google.protobuf.Empty"
+
+---Performs a unary request.
+---
+---@nodiscard
+---
+---@param data snowcap.popup.v1.CloseRequest
+---
+---@return google.protobuf.Empty | nil response
+---@return string | nil error An error string, if any
+function Client:snowcap_popup_v1_PopupService_Close(data)
+    return self:unary_request(snowcap.popup.v1.PopupService.Close, data)
+end
+snowcap.popup.v1.PopupService.OperatePopup = {}
+snowcap.popup.v1.PopupService.OperatePopup.service = "snowcap.popup.v1.PopupService"
+snowcap.popup.v1.PopupService.OperatePopup.method = "OperatePopup"
+snowcap.popup.v1.PopupService.OperatePopup.request = ".snowcap.popup.v1.OperatePopupRequest"
+snowcap.popup.v1.PopupService.OperatePopup.response = ".snowcap.popup.v1.OperatePopupResponse"
+
+---Performs a unary request.
+---
+---@nodiscard
+---
+---@param data snowcap.popup.v1.OperatePopupRequest
+---
+---@return snowcap.popup.v1.OperatePopupResponse | nil response
+---@return string | nil error An error string, if any
+function Client:snowcap_popup_v1_PopupService_OperatePopup(data)
+    return self:unary_request(snowcap.popup.v1.PopupService.OperatePopup, data)
+end
+snowcap.popup.v1.PopupService.UpdatePopup = {}
+snowcap.popup.v1.PopupService.UpdatePopup.service = "snowcap.popup.v1.PopupService"
+snowcap.popup.v1.PopupService.UpdatePopup.method = "UpdatePopup"
+snowcap.popup.v1.PopupService.UpdatePopup.request = ".snowcap.popup.v1.UpdatePopupRequest"
+snowcap.popup.v1.PopupService.UpdatePopup.response = ".snowcap.popup.v1.UpdatePopupResponse"
+
+---Performs a unary request.
+---
+---@nodiscard
+---
+---@param data snowcap.popup.v1.UpdatePopupRequest
+---
+---@return snowcap.popup.v1.UpdatePopupResponse | nil response
+---@return string | nil error An error string, if any
+function Client:snowcap_popup_v1_PopupService_UpdatePopup(data)
+    return self:unary_request(snowcap.popup.v1.PopupService.UpdatePopup, data)
+end
+snowcap.popup.v1.PopupService.RequestView = {}
+snowcap.popup.v1.PopupService.RequestView.service = "snowcap.popup.v1.PopupService"
+snowcap.popup.v1.PopupService.RequestView.method = "RequestView"
+snowcap.popup.v1.PopupService.RequestView.request = ".snowcap.popup.v1.ViewRequest"
+snowcap.popup.v1.PopupService.RequestView.response = ".snowcap.popup.v1.ViewResponse"
+
+---Performs a unary request.
+---
+---@nodiscard
+---
+---@param data snowcap.popup.v1.ViewRequest
+---
+---@return snowcap.popup.v1.ViewResponse | nil response
+---@return string | nil error An error string, if any
+function Client:snowcap_popup_v1_PopupService_RequestView(data)
+    return self:unary_request(snowcap.popup.v1.PopupService.RequestView, data)
+end
 return {
     google = google,
     snowcap = snowcap,
diff --git a/snowcap/api/lua/snowcap/grpc/protobuf.lua b/snowcap/api/lua/snowcap/grpc/protobuf.lua
index ac7b68fc2..08f6de7f5 100644
--- a/snowcap/api/lua/snowcap/grpc/protobuf.lua
+++ b/snowcap/api/lua/snowcap/grpc/protobuf.lua
@@ -17,6 +17,7 @@ function protobuf.build_protos()
         "snowcap/widget/" .. version .. "/widget.proto",
         "snowcap/operation/" .. version .. "/operation.proto",
         "snowcap/decoration/" .. version .. "/decoration.proto",
+        "snowcap/popup/" .. version .. "/popup.proto",
         "google/protobuf/empty.proto",
     }
 
diff --git a/snowcap/api/lua/snowcap/layer.lua b/snowcap/api/lua/snowcap/layer.lua
index fc0a0861a..0a3f7525e 100644
--- a/snowcap/api/lua/snowcap/layer.lua
+++ b/snowcap/api/lua/snowcap/layer.lua
@@ -17,6 +17,12 @@ local layer_handle = {}
 ---@field private _update fun(msg:any)
 local LayerHandle = {}
 
+---Convert a LayerHandle into a Popup's ParentHandle
+---@return snowcap.popup.ParentHandle
+function LayerHandle:as_parent()
+    return require("snowcap.popup").parent.Layer(self)
+end
+
 ---@param id integer
 ---@param update fun(msg: any)
 ---@return snowcap.layer.LayerHandle
@@ -164,7 +170,7 @@ end
 ---@param on_event fun(handle: snowcap.layer.LayerHandle, event: snowcap.input.KeyEvent)
 function LayerHandle:on_key_event(on_event)
     local err = client:snowcap_input_v1_InputService_KeyboardKey(
-        { id = self.id },
+        { layer_id = self.id },
         function(response)
             ---@cast response snowcap.input.v1.KeyboardKeyResponse
 
diff --git a/snowcap/api/lua/snowcap/popup.lua b/snowcap/api/lua/snowcap/popup.lua
new file mode 100644
index 000000000..8e2799858
--- /dev/null
+++ b/snowcap/api/lua/snowcap/popup.lua
@@ -0,0 +1,397 @@
+-- This Source Code Form is subject to the terms of the Mozilla Public
+-- License, v. 2.0. If a copy of the MPL was not distributed with this
+-- file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+local log = require("snowcap.log")
+local client = require("snowcap.grpc.client").client
+
+local widget = require("snowcap.widget")
+
+---Support for popup surface widgets using `xdg-shell::xdg_popup`
+---@class snowcap.popup
+local popup = {}
+
+local popup_handle = {}
+
+---A handle to a popup's parent surface.
+---@class snowcap.popup.ParentHandle
+---@field layer? integer Popup's parent surface is a Layer.
+---@field popup? integer Popup's parent surface is another Popup.
+local ParentHandle = {}
+
+function ParentHandle:__tostring()
+    if self.layer ~= nil then
+        return ("ParentHandle{Layer#%d}"):format(self.layer)
+    elseif self.popup ~= nil then
+        return("ParentHandle{Popup#%d}"):format(self.popup)
+    else
+        return "ParenHandle{empty}"
+    end
+end
+
+---Build a handle to a popup's parent surface.
+---@enum snowcap.popup.parent
+local parent = {
+    ---Build a ParentHandle from a LayerHandle.
+    ---
+    ---@param handle snowcap.layer.LayerHandle
+    ---@return snowcap.popup.ParentHandle
+    Layer = function(handle)
+        return setmetatable({ layer = handle.id }, ParentHandle)
+    end,
+    ---Build a ParentHandle from a PopupHandle.
+    ---
+    ---@param handle snowcap.popup.PopupHandle
+    ---@return snowcap.popup.ParentHandle
+    Popup = function(handle)
+        return setmetatable({ popup = handle.id }, ParentHandle)
+    end,
+}
+popup.parent = parent
+
+---A handle to a popup surface.
+---@class snowcap.popup.PopupHandle
+---@field id integer Popup's id.
+---@field private _update fun(msg:any)
+local PopupHandle = {}
+
+---Convert a PopupHandle into a Popup's ParentHandle
+---@return snowcap.popup.ParentHandle
+function PopupHandle:as_parent()
+    return parent.Popup(self)
+end
+
+---Create a new popup handle.
+---@lcat nodoc
+---@package
+---@param id integer
+---@param update fun(msg: any)
+---@return snowcap.popup.PopupHandle
+function popup_handle.new(id, update)
+    ---@type snowcap.popup.PopupHandle
+    local self = {
+        id = id,
+        _update = update,
+    }
+    setmetatable(self, { __index = PopupHandle })
+    return self
+end
+
+---Anchoring rectangle.
+---@class snowcap.popup.Rectangle
+---@field x number
+---@field y number
+---@field width number
+---@field height number
+
+---Position the Popup will be placed at.
+---
+---This is an implementation detail. Use [`snowcap.popup.position`] instead.
+---@class snowcap.popup.Position
+---@field package at_cursor? {} Position the popup at the cursor.
+---@field package absolute? snowcap.popup.Rectangle Position the popup on an arbitrary Rectangle boundaries.
+---@field package at_widget? string Position the popup on a Widget boundaries.
+
+---Position the Popup will be placed at.
+---@enum snowcap.popup.position
+local position = {
+    ---Position the popup at the cursor.
+    ---@type snowcap.popup.Position
+    AtCursor = { at_cursor = {} },
+    ---Position the anchor at an arbitrary point.
+    ---@type fun(x: number, y: number): snowcap.popup.Position
+    Point = function(x, y)
+        return {
+            absolute = {
+                x = x,
+                y = y,
+                width = 1,
+                height = 1,
+            },
+        }
+    end,
+    ---Position the anchor on a Rectangle boundaries.
+    ---@type fun(x: number, y: number, width: number, heigh: number): snowcap.popup.Position
+    Rectangle = function(x, y, width, height)
+        return {
+            absolute = {
+                x = x,
+                y = y,
+                width = width,
+                height = height,
+            },
+        }
+    end,
+    ---Position the anchor on a Widget boundaries.
+    ---@type fun(widget_id: string): snowcap.popup.Position
+    AtWidget = function(widget_id)
+        return {
+            at_widget = widget_id,
+        }
+    end,
+}
+popup.position = position
+
+---Position of the anchor point on the anchor rectangle.
+---@enum snowcap.popup.Anchor
+local anchor = {
+    TOP = 1,
+    BOTTOM = 2,
+    LEFT = 3,
+    RIGHT = 4,
+    TOP_LEFT = 5,
+    TOP_RIGHT = 6,
+    BOTTOM_LEFT = 7,
+    BOTTOM_RIGHT = 8,
+    NONE = 9,
+}
+popup.anchor = anchor
+
+---Direction of the gravity of the Popup.
+---@enum snowcap.popup.Gravity
+local gravity = {
+    TOP = 1,
+    BOTTOM = 2,
+    LEFT = 3,
+    RIGHT = 4,
+    TOP_LEFT = 5,
+    TOP_RIGHT = 6,
+    BOTTOM_LEFT = 7,
+    BOTTOM_RIGHT = 8,
+    NONE = 9,
+}
+popup.gravity = gravity
+
+---Popup position offset
+---@class snowcap.popup.Offset
+---@field x number
+---@field y number
+
+---Define ways the compositor can adjust the popup if its position would make it partially
+---constrained.
+---
+---Except for none, every field are considered part of a bitfield.
+---@class snowcap.popup.ConstraintsAdjust
+---@field none? boolean Don't move the child surface when constrained.
+---@field slide_x? boolean Move along the x axis until unconstrained.
+---@field slide_y? boolean Move along the y axis until unconstrained.
+---@field flip_x? boolean Invert the anchor and gravity on the x axis.
+---@field flip_y? boolean Invert the anchor and gravity on the y axis.
+---@field resize_x? boolean Horizontally resize the surface.
+---@field resize_y? boolean Vertically resize the surface.
+
+---popup.new_widget parameters.
+---
+---Only one parent handle will be taken into account. Setting more than one is undefined behavior.
+---@class snowcap.popup.PopupArgs
+---@field program snowcap.widget.Program Popup's content.
+---@field parent snowcap.popup.ParentHandle Popup's parent surface handle.
+---@field position snowcap.popup.Position Position the Popup should be placed at.
+---@field anchor? snowcap.popup.Anchor Popup's anchor point on the Position boundaries.
+---@field gravity? snowcap.popup.Gravity Popup's gravity.
+---@field offset? snowcap.popup.Offset Popup's offset from the ancho point.
+---@field contraints_adjust? snowcap.popup.ConstraintsAdjust Popup's contraints adjustment.
+---@field no_grab? boolean If true, the Popup will not request an explicit keyboard grab upon creation.
+---@field no_replace? boolean If true, the Popup will fail if there is already another popup with the same parent.
+
+---@param args snowcap.popup.PopupArgs
+---@return snowcap.popup.PopupHandle|nil handle A handle to the popup surface, or nil if an error occurred
+function popup.new_widget(args)
+    ---@type table<integer, any>
+    local callbacks = {}
+
+    local widget_def = args.program:view()
+
+    widget._traverse_widget_tree(widget_def, callbacks, widget._collect_callbacks)
+
+    ---@type snowcap.popup.v1.NewPopupRequest
+    local request = {
+        widget_def = widget.widget_def_into_api(widget_def),
+        position = args.position --[[@as snowcap.popup.v1.Position]],
+        anchor = args.anchor,
+        gravity = args.gravity,
+        offset = args.offset --[[@as snowcap.popup.v1.Offset]],
+        constraints_adjust = args.contraints_adjust --[[@as snowcap.popup.v1.ConstraintsAdjust]],
+        no_grab = args.no_grab,
+        no_replace = args.no_replace,
+    }
+
+    assert(args.parent, "No ParentHandle")
+
+    if args.parent.layer then
+        request.layer_id = args.parent.layer
+    elseif args.parent.popup then
+        request.popup_id = args.parent.popup
+    else
+        log.error("Parent surface missing.")
+        return nil
+    end
+
+    local response, err = client:snowcap_popup_v1_PopupService_NewPopup(request)
+
+    if err then
+        log.error(err)
+        return nil
+    end
+
+    assert(response)
+
+    if not response.popup_id then
+        log.error("no popup_id received")
+        return nil
+    end
+
+    local popup_id = response.popup_id --[[@as integer]]
+
+    err = client:snowcap_widget_v1_WidgetService_GetWidgetEvents({
+        popup_id = popup_id,
+    }, function(response) ---@diagnostic disable-line:redefined-local
+        for _, event in ipairs(response.widget_events) do
+            local msg = widget._message_from_event(callbacks, event)
+
+            if msg then
+                local ok, update_err = pcall(function()
+                    args.program:update(msg)
+                end)
+
+                if not ok then
+                    log.error(update_err)
+                end
+            end
+        end
+
+        ---@diagnostic disable-next-line:redefined-local
+        local widget_def = args.program:view()
+        callbacks = {}
+
+        widget._traverse_widget_tree(widget_def, callbacks, widget._collect_callbacks)
+
+        ---@diagnostic disable-next-line:redefined-local
+        local _, err = client:snowcap_popup_v1_PopupService_UpdatePopup({
+            popup_id = popup_id,
+            widget_def = widget.widget_def_into_api(widget_def),
+        })
+
+        if err then
+            log.error(err)
+        end
+    end)
+
+    return popup_handle.new(popup_id, function(msg)
+        args.program:update(msg)
+
+        ---@diagnostic disable-next-line: redefined-local
+        local _, err = client:snowcap_popup_v1_PopupService_RequestView({
+            popup_id = popup_id,
+        })
+
+        if err then
+            log.error(err)
+        end
+    end)
+end
+
+---Do something when a key event is received.
+---@param on_event fun(handle: snowcap.popup.PopupHandle, event: snowcap.input.KeyEvent)
+function PopupHandle:on_key_event(on_event)
+    local err = client:snowcap_input_v1_InputService_KeyboardKey(
+        { popup_id = self.id },
+        function(response)
+            ---@cast response snowcap.input.v1.KeyboardKeyResponse
+
+            local mods = response.modifiers or {}
+            mods.shift = mods.shift or false
+            mods.ctrl = mods.ctrl or false
+            mods.alt = mods.alt or false
+            mods.super = mods.super or false
+
+            ---@cast mods snowcap.input.Modifiers
+
+            ---@type snowcap.input.KeyEvent
+            local event = {
+                key = response.key or 0,
+                mods = mods,
+                pressed = response.pressed,
+                captured = response.captured,
+                text = response.text,
+            }
+
+            on_event(self, event)
+        end
+    )
+
+    if err then
+        log.error(err)
+    end
+end
+
+---Do something on key press.
+---@param on_press fun(mods: snowcap.input.Modifiers, key: snowcap.Key)
+function PopupHandle:on_key_press(on_press)
+    self:on_key_event(function(_, event)
+        if not event.pressed or event.captured then
+            return
+        end
+
+        on_press(event.mods, event.key)
+    end)
+end
+
+---Sends an `Operation` to this popup.
+---@param operation snowcap.widget.operation.Operation
+function PopupHandle:operate(operation)
+    local _, err = client:snowcap_popup_v1_PopupService_OperatePopup({
+        popup_id = self.id,
+        operation = require("snowcap.widget.operation")._to_api(operation), ---@diagnostic disable-line: invisible
+    })
+
+    if err then
+        log.error(err)
+    end
+end
+
+---PopupHandle:popup parameters.
+---
+---Any parameters set will override a previously set value.
+---@class snowcap.popup.PopupUpdateArgs
+---@field position snowcap.popup.Position? Update popup's position.
+---@field anchor snowcap.popup.Anchor? Update popup's anchor.
+---@field gravity snowcap.popup.Gravity? Update popup's gravity.
+---@field offset snowcap.popup.Offset? Update popup's offset.
+---@field constraints_adjust snowcap.popup.ConstraintsAdjust? Update popup's constraints adjustment.
+
+---Update this popup's attributes.
+---@param args snowcap.popup.PopupUpdateArgs
+---@return boolean # True if the operation succeed.
+function PopupHandle:update(args)
+    local _, err = client:snowcap_popup_v1_PopupService_UpdatePopup({
+        popup_id = self.id,
+        position = args.position --[[@as snowcap.popup.v1.Position]],
+        anchor = args.anchor --[[@as snowcap.popup.v1.Anchor]],
+        gravity = args.gravity --[[@as snowcap.popup.v1.Gravity]],
+        offset = args.offset --[[@as snowcap.popup.v1.Offset]],
+        constraints_adjust = args.constraints_adjust --[[@as snowcap.popup.v1.ConstraintsAdjust]],
+    })
+
+    if err then
+        log.error(err)
+    end
+
+    return err == nil
+end
+
+---Close this popup widget.
+function PopupHandle:close()
+    local _, err = client:snowcap_popup_v1_PopupService_Close({ popup_id = self.id })
+
+    if err then
+        log.error(err)
+    end
+end
+
+---Sends a message to this Popup [`Program`].
+function PopupHandle:send_message(message)
+    self._update(message)
+end
+
+return popup
diff --git a/snowcap/api/lua/snowcap/widget.lua b/snowcap/api/lua/snowcap/widget.lua
index 0cf965c9a..52e58fab2 100644
--- a/snowcap/api/lua/snowcap/widget.lua
+++ b/snowcap/api/lua/snowcap/widget.lua
@@ -107,6 +107,7 @@
 ---@field scroller_border snowcap.widget.Border?
 
 ---@class snowcap.widget.Container
+---@field id string?
 ---@field padding snowcap.widget.Padding?
 ---@field width snowcap.widget.Length?
 ---@field height snowcap.widget.Length?
@@ -686,6 +687,7 @@ end
 local function container_into_api(def)
     ---@type snowcap.widget.v1.Container
     return {
+        id = def.id,
         padding = def.padding --[[@as snowcap.widget.v1.Padding]],
         width = def.width --[[@as snowcap.widget.v1.Length]],
         height = def.height --[[@as snowcap.widget.v1.Length]],
diff --git a/snowcap/api/protobuf/snowcap/input/v1/input.proto b/snowcap/api/protobuf/snowcap/input/v1/input.proto
index 06f1fd4aa..62d823ed6 100644
--- a/snowcap/api/protobuf/snowcap/input/v1/input.proto
+++ b/snowcap/api/protobuf/snowcap/input/v1/input.proto
@@ -10,7 +10,10 @@ message Modifiers {
 }
 
 message KeyboardKeyRequest {
-  uint32 id = 1;
+  oneof target {
+    uint32 layer_id = 1;
+    uint32 popup_id = 2;
+  }
 }
 
 message KeyboardKeyResponse {
diff --git a/snowcap/api/protobuf/snowcap/popup/v1/popup.proto b/snowcap/api/protobuf/snowcap/popup/v1/popup.proto
new file mode 100644
index 000000000..cdc563bda
--- /dev/null
+++ b/snowcap/api/protobuf/snowcap/popup/v1/popup.proto
@@ -0,0 +1,117 @@
+syntax = "proto3";
+
+package snowcap.popup.v1;
+
+import "google/protobuf/empty.proto";
+import "snowcap/widget/v1/widget.proto";
+import "snowcap/operation/v1/operation.proto";
+
+enum Anchor {
+  ANCHOR_UNSPECIFIED = 0;
+  ANCHOR_TOP = 1;
+  ANCHOR_BOTTOM = 2;
+  ANCHOR_LEFT = 3;
+  ANCHOR_RIGHT = 4;
+  ANCHOR_TOP_LEFT = 5;
+  ANCHOR_TOP_RIGHT = 6;
+  ANCHOR_BOTTOM_LEFT = 7;
+  ANCHOR_BOTTOM_RIGHT = 8;
+  ANCHOR_NONE = 9;
+}
+
+enum Gravity {
+  GRAVITY_UNSPECIFIED = 0;
+  GRAVITY_TOP = 1;
+  GRAVITY_BOTTOM = 2;
+  GRAVITY_LEFT = 3;
+  GRAVITY_RIGHT = 4;
+  GRAVITY_TOP_LEFT = 5;
+  GRAVITY_TOP_RIGHT = 6;
+  GRAVITY_BOTTOM_LEFT = 7;
+  GRAVITY_BOTTOM_RIGHT = 8;
+  GRAVITY_NONE = 9;
+}
+
+message Offset {
+  float x = 1;
+  float y = 2;
+}
+
+message Rectangle {
+  float x = 1;
+  float y = 2;
+  float width = 3;
+  float height = 4;
+}
+
+message ConstraintsAdjust {
+  bool none = 1;
+  bool slide_x = 2;
+  bool slide_y = 3;
+  bool flip_x = 4;
+  bool flip_y = 5;
+  bool resize_x = 6;
+  bool resize_y = 7;
+}
+
+message Position {
+  oneof strategy {
+    google.protobuf.Empty at_cursor = 1;
+    Rectangle absolute = 2;
+    string at_widget = 3;
+  }
+}
+
+message NewPopupRequest {
+  snowcap.widget.v1.WidgetDef widget_def = 1;
+  oneof parent_id {
+    uint32 layer_id = 2;
+    uint32 deco_id = 3;
+    uint32 popup_id = 4;
+  }
+  Position position = 5;
+  Anchor anchor = 6;
+  Gravity gravity = 7;
+  Offset offset = 8;
+  ConstraintsAdjust constraints_adjust = 9;
+  bool no_grab = 10;
+  bool no_replace = 11;
+}
+
+message NewPopupResponse {
+  uint32 popup_id = 1;
+}
+
+message CloseRequest {
+  uint32 popup_id = 1;
+}
+
+message OperatePopupRequest {
+  uint32 popup_id = 1;
+  snowcap.operation.v1.Operation operation = 2;
+}
+message OperatePopupResponse {}
+
+message UpdatePopupRequest {
+  uint32 popup_id = 1;
+  optional snowcap.widget.v1.WidgetDef widget_def = 2;
+  optional Position position = 5;
+  optional Anchor anchor = 6;
+  optional Gravity gravity = 7;
+  optional Offset offset = 8;
+  optional ConstraintsAdjust constraints_adjust = 9;
+}
+message UpdatePopupResponse {}
+
+message ViewRequest {
+  uint32 popup_id = 1;
+}
+message ViewResponse {}
+
+service PopupService {
+  rpc NewPopup(NewPopupRequest) returns (NewPopupResponse);
+  rpc Close(CloseRequest) returns (google.protobuf.Empty);
+  rpc OperatePopup(OperatePopupRequest) returns (OperatePopupResponse);
+  rpc UpdatePopup(UpdatePopupRequest) returns (UpdatePopupResponse);
+  rpc RequestView(ViewRequest) returns (ViewResponse);
+}
diff --git a/snowcap/api/protobuf/snowcap/widget/v1/widget.proto b/snowcap/api/protobuf/snowcap/widget/v1/widget.proto
index 9713fde17..9cd3a2261 100644
--- a/snowcap/api/protobuf/snowcap/widget/v1/widget.proto
+++ b/snowcap/api/protobuf/snowcap/widget/v1/widget.proto
@@ -259,6 +259,7 @@ message Container {
   optional bool clip = 8;
   WidgetDef child = 9;
   optional Style style = 10;
+  optional string id = 11;
 
   message Style {
     optional Color text_color = 1;
@@ -466,6 +467,7 @@ message GetWidgetEventsRequest {
   oneof id {
     uint32 layer_id = 1;
     uint32 decoration_id = 2;
+    uint32 popup_id = 3;
   }
 }
 
diff --git a/snowcap/api/rust/Cargo.toml b/snowcap/api/rust/Cargo.toml
index 2050d7a19..ce7077f83 100644
--- a/snowcap/api/rust/Cargo.toml
+++ b/snowcap/api/rust/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2024"
 rust-version.workspace = true
 
 [dependencies]
+bitflags = { workspace = true }
 from_variants = "1.0.2"
 futures = { workspace = true }
 hyper-util = { workspace = true }
diff --git a/snowcap/api/rust/src/client.rs b/snowcap/api/rust/src/client.rs
index 5604e709a..383966e98 100644
--- a/snowcap/api/rust/src/client.rs
+++ b/snowcap/api/rust/src/client.rs
@@ -6,6 +6,7 @@ use snowcap_api_defs::snowcap::{
     decoration::v1::decoration_service_client::DecorationServiceClient,
     input::v1::input_service_client::InputServiceClient,
     layer::v1::layer_service_client::LayerServiceClient,
+    popup::v1::popup_service_client::PopupServiceClient,
     widget::v1::widget_service_client::WidgetServiceClient,
 };
 use tokio::sync::{RwLock, RwLockReadGuard};
@@ -20,6 +21,7 @@ pub struct Client {
     input: InputServiceClient<Channel>,
     widget: WidgetServiceClient<Channel>,
     decoration: DecorationServiceClient<Channel>,
+    popup: PopupServiceClient<Channel>,
 }
 
 impl Client {
@@ -39,6 +41,10 @@ impl Client {
         Self::get().layer.clone()
     }
 
+    pub fn popup() -> PopupServiceClient<Channel> {
+        Self::get().popup.clone()
+    }
+
     pub fn input() -> InputServiceClient<Channel> {
         Self::get().input.clone()
     }
@@ -57,6 +63,7 @@ impl Client {
             input: InputServiceClient::new(channel.clone()),
             widget: WidgetServiceClient::new(channel.clone()),
             decoration: DecorationServiceClient::new(channel.clone()),
+            popup: PopupServiceClient::new(channel.clone()),
         }
     }
 }
diff --git a/snowcap/api/rust/src/layer.rs b/snowcap/api/rust/src/layer.rs
index 459197bea..5198dd90e 100644
--- a/snowcap/api/rust/src/layer.rs
+++ b/snowcap/api/rust/src/layer.rs
@@ -3,7 +3,7 @@
 use std::{collections::HashMap, num::NonZeroU32};
 
 use snowcap_api_defs::snowcap::{
-    input::v1::KeyboardKeyRequest,
+    input::v1::{KeyboardKeyRequest, keyboard_key_request::Target},
     layer::{
         self,
         v1::{CloseRequest, NewLayerRequest, OperateLayerRequest, UpdateLayerRequest, ViewRequest},
@@ -19,6 +19,7 @@ use crate::{
     BlockOnTokio,
     client::Client,
     input::{KeyEvent, Modifiers},
+    popup::{self, AsParent},
     widget::{self, Program, WidgetDef, WidgetId, WidgetMessage},
 };
 
@@ -349,7 +350,7 @@ where
     ) {
         let mut stream = match Client::input()
             .keyboard_key(KeyboardKeyRequest {
-                id: self.id.to_inner(),
+                target: Some(Target::LayerId(self.id.to_inner())),
             })
             .block_on_tokio()
         {
@@ -385,3 +386,9 @@ where
         });
     }
 }
+
+impl<Msg> AsParent for LayerHandle<Msg> {
+    fn as_parent(&self) -> crate::popup::Parent {
+        popup::Parent(popup::ParentInner::Layer(self.id))
+    }
+}
diff --git a/snowcap/api/rust/src/lib.rs b/snowcap/api/rust/src/lib.rs
index c53802e2a..bcfe15e28 100644
--- a/snowcap/api/rust/src/lib.rs
+++ b/snowcap/api/rust/src/lib.rs
@@ -15,6 +15,7 @@ mod client;
 pub mod decoration;
 pub mod input;
 pub mod layer;
+pub mod popup;
 pub mod widget;
 
 use client::Client;
diff --git a/snowcap/api/rust/src/popup.rs b/snowcap/api/rust/src/popup.rs
new file mode 100644
index 000000000..966d700e8
--- /dev/null
+++ b/snowcap/api/rust/src/popup.rs
@@ -0,0 +1,551 @@
+//! Support for popup surface widgets using `xdg-shell::xdg_popup`
+
+use std::collections::HashMap;
+
+use bitflags::bitflags;
+use snowcap_api_defs::snowcap::{
+    input::v1::{KeyboardKeyRequest, keyboard_key_request::Target},
+    popup::{
+        self,
+        v1::{CloseRequest, NewPopupRequest, OperatePopupRequest, UpdatePopupRequest, ViewRequest},
+    },
+    widget::v1::{GetWidgetEventsRequest, get_widget_events_request},
+};
+use tokio::sync::mpsc::UnboundedSender;
+use tokio_stream::StreamExt;
+use xkbcommon::xkb::Keysym;
+
+use crate::{
+    BlockOnTokio,
+    client::Client,
+    input::{KeyEvent, Modifiers},
+    widget::{self, Program, WidgetDef, WidgetId, WidgetMessage},
+};
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) enum ParentInner {
+    Layer(WidgetId),
+    Popup(WidgetId),
+}
+
+/// Popup Parent surface.
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Parent(pub(crate) ParentInner);
+
+/// Position the Popup will be placed at.
+#[allow(missing_docs)]
+#[derive(Debug, Clone, PartialEq)]
+pub enum Position {
+    /// Position the anchor point at the cursor.
+    AtCursor,
+    /// Position the anchor at an arbitrary point.
+    Point { x: f32, y: f32 },
+    /// Position the anchor on a Rectangle boundaries.
+    Rectangle {
+        x: f32,
+        y: f32,
+        width: f32,
+        height: f32,
+    },
+    /// Position the anchor on a Widget boundaries.
+    AtWidget(String),
+}
+
+impl Position {
+    /// Create a new Position to place a Popup at the cursor location.
+    pub fn at_cursor() -> Self {
+        Position::AtCursor
+    }
+
+    /// Create a new Position to place a Popup at an arbitrary point.
+    pub fn point(x: f32, y: f32) -> Self {
+        Position::Point { x, y }
+    }
+
+    /// Create a new Position to place a Popup on an arbitrary rectangle.
+    pub fn rectangle(x: f32, y: f32, width: f32, height: f32) -> Self {
+        Position::Rectangle {
+            x,
+            y,
+            width,
+            height,
+        }
+    }
+
+    /// Create a new Position to place a Popup relative to a Widget.
+    pub fn at_widget(id: impl Into<String>) -> Self {
+        Position::AtWidget(id.into())
+    }
+}
+
+/// Position of the anchor point on the anchor rectangle.
+#[allow(missing_docs)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum Anchor {
+    None,
+    Top,
+    Bottom,
+    Left,
+    Right,
+    TopLeft,
+    TopRight,
+    BottomLeft,
+    BottomRight,
+}
+
+/// Direction of the gravity of the Popup.
+#[allow(missing_docs)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum Gravity {
+    None,
+    Top,
+    Bottom,
+    Left,
+    Right,
+    TopLeft,
+    TopRight,
+    BottomLeft,
+    BottomRight,
+}
+
+/// Popup position offset
+#[allow(missing_docs)]
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct Offset {
+    pub x: f32,
+    pub y: f32,
+}
+
+bitflags! {
+    /// Define ways the compositor can adjust the popup if its position would make it partially
+    /// constrained.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct ConstraintsAdjust: u32 {
+        /// Don't move the child surface when constrained.
+        const None = 0;
+        /// Move along the x axis until unconstrained.
+        const SlideX = 1;
+        /// Move along the y axis until unconstrained.
+        const SlideY = 2;
+        /// Invert the anchor and gravity on the x axis.
+        const FlipX = 4;
+        /// Invert the anchor and gravity on the y axis.
+        const FlipY = 8;
+        /// Horizontally resize the surface.
+        const ResizeX = 16;
+        /// Vertically resize the surface.
+        const ResizeY = 32;
+    }
+}
+
+/// The error type for [`Popup::new_widget`].
+///
+/// [`Popup::new_widget`]: self::new_widget
+#[derive(thiserror::Error, Debug)]
+pub enum NewPopupError {
+    /// Snowcap returned a gRPC error status.
+    #[error("gRPC error: `{0}`")]
+    GrpcStatus(#[from] tonic::Status),
+}
+
+/// The error type for [`PopupHandle::update`].
+#[derive(thiserror::Error, Debug)]
+pub enum UpdatePopupError {
+    /// Snowcap returned a gRPC error status.
+    #[error("gRPC error: `{0}`")]
+    GrpcStatus(#[from] tonic::Status),
+}
+
+/// Create a new popup.
+pub fn new_widget<Msg, P>(
+    mut program: P,
+    parent: &impl AsParent,
+    position: Position,
+    anchor: Option<Anchor>,
+    gravity: Option<Gravity>,
+    offset: Option<Offset>,
+    constraints_adjust: Option<ConstraintsAdjust>,
+    no_grab: bool,
+    no_replace: bool,
+) -> Result<PopupHandle<Msg>, NewPopupError>
+where
+    Msg: Clone + Send + 'static,
+    P: Program<Message = Msg> + Send + 'static,
+{
+    let mut callbacks = HashMap::<WidgetId, WidgetMessage<Msg>>::new();
+
+    let widget_def = program.view();
+
+    widget_def.collect_messages(&mut callbacks, WidgetDef::message_collector);
+
+    let response = Client::popup()
+        .new_popup(NewPopupRequest {
+            widget_def: Some(widget_def.clone().into()),
+            parent_id: Some(parent.as_parent().into()),
+            position: Some(position.into()),
+            anchor: anchor
+                .map(From::from)
+                .unwrap_or(popup::v1::Anchor::Unspecified) as i32,
+            gravity: gravity
+                .map(From::from)
+                .unwrap_or(popup::v1::Gravity::Unspecified) as i32,
+            offset: offset.map(From::from),
+            constraints_adjust: constraints_adjust.map(From::from),
+            no_grab,
+            no_replace,
+        })
+        .block_on_tokio()?;
+
+    let popup_id = response.into_inner().popup_id;
+
+    let mut event_stream = Client::widget()
+        .get_widget_events(GetWidgetEventsRequest {
+            id: Some(get_widget_events_request::Id::PopupId(popup_id)),
+        })
+        .block_on_tokio()?
+        .into_inner();
+
+    let (msg_send, mut msg_recv) = tokio::sync::mpsc::unbounded_channel::<Msg>();
+
+    tokio::spawn(async move {
+        loop {
+            tokio::select! {
+                Some(Ok(response)) = event_stream.next() => {
+                    for widget_event in response.widget_events {
+                        let Some(msg) = widget::message_from_event(&callbacks, widget_event) else {
+                            continue;
+                        };
+
+                        program.update(msg);
+                    }
+                }
+                Some(msg) = msg_recv.recv() => {
+                    program.update(msg);
+
+                    if let Err(status) = Client::popup()
+                        .request_view(ViewRequest { popup_id })
+                        .block_on_tokio()
+                    {
+                        tracing::error!("Failed to request view for {popup_id}: {status}");
+                    }
+
+                    continue;
+                }
+                else => break,
+            };
+
+            let widget_def = program.view();
+
+            callbacks.clear();
+
+            widget_def.collect_messages(&mut callbacks, WidgetDef::message_collector);
+
+            Client::popup()
+                .update_popup(UpdatePopupRequest {
+                    popup_id,
+                    widget_def: Some(widget_def.into()),
+                    ..Default::default()
+                })
+                .await
+                .unwrap();
+        }
+    });
+
+    Ok(PopupHandle {
+        id: popup_id.into(),
+        msg_sender: msg_send,
+    })
+}
+
+/// A handle to a popup surface.
+#[derive(Clone)]
+pub struct PopupHandle<Msg> {
+    id: WidgetId,
+    msg_sender: UnboundedSender<Msg>,
+}
+
+impl<Msg> PopupHandle<Msg> {
+    /// Close this popup widget.
+    pub fn close(&self) {
+        if let Err(status) = Client::popup()
+            .close(CloseRequest {
+                popup_id: self.id.to_inner(),
+            })
+            .block_on_tokio()
+        {
+            tracing::error!("Failed to close {self:?}: {status}");
+        }
+    }
+}
+
+impl<Msg> PopupHandle<Msg>
+where
+    Msg: Clone + Send + 'static,
+{
+    /// Update this popup's attributes.
+    pub fn update(
+        &self,
+        position: Option<Position>,
+        anchor: Option<Anchor>,
+        gravity: Option<Gravity>,
+        offset: Option<Offset>,
+        constraints_adjust: Option<ConstraintsAdjust>,
+    ) -> Result<(), UpdatePopupError> {
+        Client::popup()
+            .update_popup(UpdatePopupRequest {
+                popup_id: self.id.to_inner(),
+                widget_def: None,
+                position: position.map(From::from),
+                anchor: anchor
+                    .map(From::from)
+                    .or(Some(popup::v1::Anchor::Unspecified))
+                    .map(i32::from),
+                gravity: gravity
+                    .map(From::from)
+                    .or(Some(popup::v1::Gravity::Unspecified))
+                    .map(i32::from),
+                offset: offset.map(From::from),
+                constraints_adjust: constraints_adjust.map(From::from),
+            })
+            .block_on_tokio()?;
+
+        Ok(())
+    }
+
+    /// Update this popup's position.
+    pub fn set_position(&self, position: Position) -> Result<(), UpdatePopupError> {
+        self.update(Some(position), None, None, None, None)
+    }
+
+    /// Update this popup's anchor.
+    pub fn set_anchor(&self, anchor: Anchor) -> Result<(), UpdatePopupError> {
+        self.update(None, Some(anchor), None, None, None)
+    }
+
+    /// Update this popup's gravity.
+    pub fn set_gravity(&self, gravity: Gravity) -> Result<(), UpdatePopupError> {
+        self.update(None, None, Some(gravity), None, None)
+    }
+
+    /// Update this popup's offset.
+    pub fn set_offset(&self, offset: Offset) -> Result<(), UpdatePopupError> {
+        self.update(None, None, None, Some(offset), None)
+    }
+
+    /// Update this popup's contraints adjustment.
+    pub fn set_constraints_adjust(
+        &self,
+        constraints_adjust: ConstraintsAdjust,
+    ) -> Result<(), UpdatePopupError> {
+        self.update(None, None, None, None, Some(constraints_adjust))
+    }
+
+    /// Sends an [`Operation`] to this Popup.
+    ///
+    /// [`Operation`]: widget::operation::Operation
+    pub fn operate(&self, operation: widget::operation::Operation) {
+        if let Err(status) = Client::popup()
+            .operate_popup(OperatePopupRequest {
+                popup_id: self.id.to_inner(),
+                operation: Some(operation.into()),
+            })
+            .block_on_tokio()
+        {
+            tracing::error!("Failed to send operation to {self:?}: {status}");
+        }
+    }
+
+    /// Sends a message to this Popup [`Program`].
+    pub fn send_message(&self, message: Msg) {
+        let _ = self.msg_sender.send(message);
+    }
+
+    /// Do something when a key event is received.
+    pub fn on_key_event(
+        &self,
+        mut on_event: impl FnMut(PopupHandle<Msg>, KeyEvent) + Send + 'static,
+    ) {
+        let mut stream = match Client::input()
+            .keyboard_key(KeyboardKeyRequest {
+                target: Some(Target::PopupId(self.id.to_inner())),
+            })
+            .block_on_tokio()
+        {
+            Ok(stream) => stream.into_inner(),
+            Err(status) => {
+                tracing::error!("Failed to set `on_key_event` handler: {status}");
+                return;
+            }
+        };
+
+        let handle = self.clone();
+
+        tokio::spawn(async move {
+            while let Some(Ok(response)) = stream.next().await {
+                let event = KeyEvent::from(response);
+
+                on_event(handle.clone(), event);
+            }
+        });
+    }
+
+    /// Do something on key press.
+    pub fn on_key_press(
+        &self,
+        mut on_press: impl FnMut(PopupHandle<Msg>, Keysym, Modifiers) + Send + 'static,
+    ) {
+        self.on_key_event(move |handle, event| {
+            if !event.pressed || event.captured {
+                return;
+            }
+
+            on_press(handle, event.key, event.mods)
+        });
+    }
+}
+
+impl<Msg> std::fmt::Debug for PopupHandle<Msg> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("PopupHandle").field("id", &self.id).finish()
+    }
+}
+
+impl std::fmt::Debug for Parent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.0 {
+            ParentInner::Layer(id) => f.debug_tuple("Parent::Layer").field(&id).finish(),
+            ParentInner::Popup(id) => f.debug_tuple("Parent::Popup").field(&id).finish(),
+            // ParentInner::Decoration(id) => f.debug_tuple("Parent::Decoration").field(&id).finish(),
+        }
+    }
+}
+
+/// Used to convert a handle to a popup's [`Parent`].
+pub trait AsParent {
+    /// Convert a reference to a surface handle to a popup [`Parent`].
+    fn as_parent(&self) -> Parent;
+}
+
+impl<Msg> AsParent for PopupHandle<Msg> {
+    fn as_parent(&self) -> Parent {
+        Parent(ParentInner::Popup(self.id))
+    }
+}
+
+impl AsParent for Parent {
+    fn as_parent(&self) -> Parent {
+        *self
+    }
+}
+
+impl From<Parent> for popup::v1::new_popup_request::ParentId {
+    fn from(value: Parent) -> Self {
+        use popup::v1::new_popup_request::ParentId;
+        match value.0 {
+            ParentInner::Layer(id) => ParentId::LayerId(id.to_inner()),
+            ParentInner::Popup(id) => ParentId::PopupId(id.to_inner()),
+            // ParentInner::Decoration(id) => ParentId::DecoId(id.to_inner()),
+        }
+    }
+}
+
+impl From<Position> for popup::v1::Position {
+    fn from(value: Position) -> Self {
+        Self {
+            strategy: Some(value.into()),
+        }
+    }
+}
+
+impl From<Position> for popup::v1::position::Strategy {
+    fn from(value: Position) -> Self {
+        use popup::v1::{Rectangle, position::Strategy};
+
+        match value {
+            Position::AtCursor => Strategy::AtCursor(()),
+            Position::Point { x, y } => Strategy::Absolute(Rectangle {
+                x,
+                y,
+                width: 1.,
+                height: 1.,
+            }),
+            Position::Rectangle {
+                x,
+                y,
+                width,
+                height,
+            } => Strategy::Absolute(Rectangle {
+                x,
+                y,
+                width,
+                height,
+            }),
+            Position::AtWidget(id) => Strategy::AtWidget(id),
+        }
+    }
+}
+
+impl From<Anchor> for popup::v1::Anchor {
+    fn from(value: Anchor) -> Self {
+        use popup::v1;
+
+        match value {
+            Anchor::None => v1::Anchor::None,
+            Anchor::Top => v1::Anchor::Top,
+            Anchor::Bottom => v1::Anchor::Bottom,
+            Anchor::Left => v1::Anchor::Left,
+            Anchor::Right => v1::Anchor::Right,
+            Anchor::TopLeft => v1::Anchor::TopLeft,
+            Anchor::TopRight => v1::Anchor::TopRight,
+            Anchor::BottomLeft => v1::Anchor::BottomLeft,
+            Anchor::BottomRight => v1::Anchor::BottomRight,
+        }
+    }
+}
+
+impl From<Gravity> for popup::v1::Gravity {
+    fn from(value: Gravity) -> Self {
+        use popup::v1;
+
+        match value {
+            Gravity::None => v1::Gravity::None,
+            Gravity::Top => v1::Gravity::Top,
+            Gravity::Bottom => v1::Gravity::Bottom,
+            Gravity::Left => v1::Gravity::Left,
+            Gravity::Right => v1::Gravity::Right,
+            Gravity::TopLeft => v1::Gravity::TopLeft,
+            Gravity::TopRight => v1::Gravity::TopRight,
+            Gravity::BottomLeft => v1::Gravity::BottomLeft,
+            Gravity::BottomRight => v1::Gravity::BottomRight,
+        }
+    }
+}
+
+impl From<Offset> for popup::v1::Offset {
+    fn from(value: Offset) -> Self {
+        let Offset { x, y } = value;
+
+        Self { x, y }
+    }
+}
+
+impl From<ConstraintsAdjust> for popup::v1::ConstraintsAdjust {
+    fn from(value: ConstraintsAdjust) -> Self {
+        if value == ConstraintsAdjust::None {
+            return Self {
+                none: true,
+                ..Default::default()
+            };
+        };
+
+        Self {
+            none: false,
+            slide_x: value.contains(ConstraintsAdjust::SlideX),
+            slide_y: value.contains(ConstraintsAdjust::SlideY),
+            flip_x: value.contains(ConstraintsAdjust::FlipX),
+            flip_y: value.contains(ConstraintsAdjust::FlipY),
+            resize_x: value.contains(ConstraintsAdjust::ResizeX),
+            resize_y: value.contains(ConstraintsAdjust::ResizeY),
+        }
+    }
+}
diff --git a/snowcap/api/rust/src/widget/container.rs b/snowcap/api/rust/src/widget/container.rs
index 91bededb9..00ca46f65 100644
--- a/snowcap/api/rust/src/widget/container.rs
+++ b/snowcap/api/rust/src/widget/container.rs
@@ -16,6 +16,7 @@ pub struct Container<Msg> {
     pub clip: Option<bool>,
     pub child: WidgetDef<Msg>,
     pub style: Option<Style>,
+    pub id: Option<String>,
 }
 
 impl<Msg> Container<Msg> {
@@ -31,6 +32,14 @@ impl<Msg> Container<Msg> {
             vertical_alignment: None,
             clip: None,
             style: None,
+            id: None,
+        }
+    }
+
+    pub fn id(self, id: impl ToString) -> Self {
+        Self {
+            id: Some(id.to_string()),
+            ..self
         }
     }
 
@@ -115,6 +124,7 @@ impl<Msg> From<Container<Msg>> for widget::v1::Container {
             clip: value.clip,
             child: Some(Box::new(value.child.into())),
             style: value.style.map(From::from),
+            id: value.id,
         }
     }
 }
diff --git a/snowcap/snowcap-api-defs/src/lib.rs b/snowcap/snowcap-api-defs/src/lib.rs
index 839aaf155..e9590d0b4 100644
--- a/snowcap/snowcap-api-defs/src/lib.rs
+++ b/snowcap/snowcap-api-defs/src/lib.rs
@@ -35,6 +35,12 @@ pub mod snowcap {
         }
     }
 
+    pub mod popup {
+        pub mod v1 {
+            tonic::include_proto!("snowcap.popup.v1");
+        }
+    }
+
     pub mod operation {
         pub mod v1 {
             tonic::include_proto!("snowcap.operation.v1");
diff --git a/snowcap/src/api.rs b/snowcap/src/api.rs
index 880f2ab14..d3b912e40 100644
--- a/snowcap/src/api.rs
+++ b/snowcap/src/api.rs
@@ -2,6 +2,7 @@ pub mod decoration;
 pub mod input;
 pub mod layer;
 pub mod operation;
+pub mod popup;
 pub mod widget;
 
 use std::pin::Pin;
diff --git a/snowcap/src/api/input/v1.rs b/snowcap/src/api/input/v1.rs
index 034a21e10..8e2af2e5d 100644
--- a/snowcap/src/api/input/v1.rs
+++ b/snowcap/src/api/input/v1.rs
@@ -10,6 +10,7 @@ use tonic::{Request, Response, Status};
 use crate::{
     api::{ResponseStream, run_server_streaming, run_server_streaming_mapped},
     layer::LayerId,
+    popup::PopupId,
 };
 
 #[tonic::async_trait]
@@ -23,13 +24,22 @@ impl input_service_server::InputService for super::InputService {
     ) -> Result<Response<Self::KeyboardKeyStream>, Status> {
         let request = request.into_inner();
 
-        let id = LayerId(request.id);
+        let Some(target) = request.target.map(Target::from) else {
+            return Err(Status::invalid_argument("no target"));
+        };
 
         run_server_streaming_mapped(
             &self.sender,
-            move |state, sender| {
-                if let Some(layer) = state.layer_for_id(id) {
-                    layer.keyboard_key_sender = Some(sender);
+            move |state, sender| match target {
+                Target::Layer(id) => {
+                    if let Some(layer) = state.layer_for_id(id) {
+                        layer.keyboard_key_sender = Some(sender);
+                    }
+                }
+                Target::Popup(id) => {
+                    if let Some(popup) = state.popup_for_id(id) {
+                        popup.keyboard_key_sender = Some(sender);
+                    }
                 }
             },
             |item| {
@@ -61,3 +71,19 @@ impl input_service_server::InputService for super::InputService {
         run_server_streaming(&self.sender, move |_state, _sender| todo!())
     }
 }
+
+enum Target {
+    Layer(LayerId),
+    Popup(PopupId),
+}
+
+impl From<input::v1::keyboard_key_request::Target> for Target {
+    fn from(value: input::v1::keyboard_key_request::Target) -> Self {
+        use input::v1::keyboard_key_request::{self as api};
+
+        match value {
+            api::Target::LayerId(id) => Target::Layer(LayerId(id)),
+            api::Target::PopupId(id) => Target::Popup(PopupId(id)),
+        }
+    }
+}
diff --git a/snowcap/src/api/layer/v0alpha1.rs b/snowcap/src/api/layer/v0alpha1.rs
index ee3c68584..30168c0ab 100644
--- a/snowcap/src/api/layer/v0alpha1.rs
+++ b/snowcap/src/api/layer/v0alpha1.rs
@@ -115,7 +115,7 @@ impl layer_service_server::LayerService for super::LayerService {
         let id = LayerId(id);
 
         run_unary_no_response(&self.sender, move |state| {
-            state.layers.retain(|sn_layer| sn_layer.layer_id != id);
+            state.layer_destroy(id);
         })
         .await
     }
diff --git a/snowcap/src/api/layer/v1.rs b/snowcap/src/api/layer/v1.rs
index 642bdea9d..3633e9ca7 100644
--- a/snowcap/src/api/layer/v1.rs
+++ b/snowcap/src/api/layer/v1.rs
@@ -103,7 +103,7 @@ impl layer_service_server::LayerService for super::LayerService {
         let id = LayerId(id);
 
         run_unary_no_response(&self.sender, move |state| {
-            state.layers.retain(|sn_layer| sn_layer.layer_id != id);
+            state.layer_destroy(id);
         })
         .await
     }
diff --git a/snowcap/src/api/popup.rs b/snowcap/src/api/popup.rs
new file mode 100644
index 000000000..160067870
--- /dev/null
+++ b/snowcap/src/api/popup.rs
@@ -0,0 +1,14 @@
+mod v1;
+
+use super::StateFnSender;
+
+#[derive(Clone)]
+pub struct PopupService {
+    sender: StateFnSender,
+}
+
+impl PopupService {
+    pub fn new(sender: StateFnSender) -> Self {
+        Self { sender }
+    }
+}
diff --git a/snowcap/src/api/popup/v1.rs b/snowcap/src/api/popup/v1.rs
new file mode 100644
index 000000000..8d3c65fe0
--- /dev/null
+++ b/snowcap/src/api/popup/v1.rs
@@ -0,0 +1,419 @@
+use anyhow::Context;
+use smithay_client_toolkit::reexports::protocols::xdg::shell::client::xdg_positioner;
+use snowcap_api_defs::snowcap::popup::v1::{
+    self, CloseRequest, NewPopupRequest, NewPopupResponse, OperatePopupRequest,
+    OperatePopupResponse, UpdatePopupRequest, UpdatePopupResponse, ViewRequest, ViewResponse,
+    new_popup_request::{self, ParentId},
+    popup_service_server,
+};
+use tonic::{Request, Response, Status};
+
+use crate::{
+    api::{run_unary, run_unary_no_response, widget::v1::widget_def_to_fn},
+    decoration::DecorationId,
+    layer::LayerId,
+    popup::{self, PopupId, SnowcapPopup},
+    util::convert::{FromApi, TryFromApi},
+};
+
+#[tonic::async_trait]
+impl popup_service_server::PopupService for super::PopupService {
+    async fn new_popup(
+        &self,
+        request: Request<NewPopupRequest>,
+    ) -> Result<Response<NewPopupResponse>, Status> {
+        let request = request.into_inner();
+
+        let Some(parent_id) = request.parent_id else {
+            return Err(Status::invalid_argument("no parent id"));
+        };
+
+        if matches!(parent_id, ParentId::DecoId(_)) {
+            return Err(Status::unimplemented("Decoration's popup are unavailable."));
+        }
+
+        let parent_id: popup::ParentId = parent_id.into();
+
+        let Some(position) = request.position.clone().map(popup::Position::from) else {
+            return Err(Status::invalid_argument("no position."));
+        };
+        let anchor = Option::from_api(request.anchor());
+        let gravity = Option::from_api(request.gravity());
+        let offset = request.offset.map(popup::Offset::from);
+        let constraints_adjust = request
+            .constraints_adjust
+            .map(xdg_positioner::ConstraintAdjustment::from_api);
+
+        let Some(widget_def) = request.widget_def else {
+            return Err(Status::invalid_argument("no widget def"));
+        };
+
+        let grab_keyboard = !request.no_grab;
+        let replace = !request.no_replace;
+
+        run_unary(&self.sender, move |state| {
+            let Some(f) = crate::api::widget::v1::widget_def_to_fn(widget_def) else {
+                return Err(Status::invalid_argument("widget def was null"));
+            };
+
+            let existing = state
+                .popups
+                .iter()
+                .find(|p| p.parent_id == parent_id)
+                .map(|p| p.popup_id);
+            if let Some(existing) = existing
+                && replace
+            {
+                state.popup_destroy(existing);
+            } else if existing.is_some() {
+                return Err(Status::failed_precondition(
+                    "Another popup with the same parent already exists",
+                ));
+            }
+
+            let toplevel_id = match parent_id {
+                popup::ParentId::Popup(popup_id) => state
+                    .popups
+                    .iter()
+                    .find(|p| p.popup_id == popup_id)
+                    .map(|p| p.toplevel_id),
+                _ => Some(parent_id),
+            };
+
+            // INFO: This is kinda the nuclear option. The original idea was to dismiss the popup
+            // stack with keyboard focus since we can't have more than one, but Smithay doesn't
+            // update focus when a popup is destroyed so we can't rely on this. It may be possible
+            // to filter-out non-grabbing popups, but I'm not sure it's worth doing so anyway. As
+            // it stand, we can only have one popup stack for Snowcap.
+
+            let existing = state
+                .popups
+                .iter()
+                .find(|p| Some(p.toplevel_id) != toplevel_id)
+                .map(|p| p.popup_id);
+            if let Some(existing) = existing
+                && replace
+            {
+                state.popup_destroy(existing);
+            } else if existing.is_some() {
+                return Err(Status::failed_precondition("Another popup already exists."));
+            }
+
+            let popup = SnowcapPopup::new(
+                state,
+                parent_id,
+                position,
+                anchor,
+                gravity,
+                offset,
+                constraints_adjust,
+                grab_keyboard,
+                f,
+            )
+            .map_err(|e| {
+                use popup::Error;
+
+                match e {
+                    Error::ParentNotFound => Status::invalid_argument("parent not found."),
+                    Error::ToplevelNotFound => {
+                        Status::invalid_argument("toplevel surface not found.")
+                    }
+                    Error::InvalidPosition => Status::invalid_argument("invalid position."),
+                    Error::Positioner => Status::internal("Failed to create positioner."),
+                    Error::CreateFailed => Status::internal("Failed to create popup."),
+                }
+            })?;
+
+            let ret = Ok(NewPopupResponse {
+                popup_id: popup.popup_id.0,
+            });
+
+            state.popups.push(popup);
+
+            ret
+        })
+        .await
+    }
+
+    async fn close(&self, request: Request<CloseRequest>) -> Result<Response<()>, Status> {
+        let request = request.into_inner();
+
+        let id = request.popup_id;
+        let id = PopupId(id);
+
+        run_unary_no_response(&self.sender, move |state| {
+            state.popup_destroy(id);
+        })
+        .await
+    }
+
+    async fn operate_popup(
+        &self,
+        request: Request<OperatePopupRequest>,
+    ) -> Result<Response<OperatePopupResponse>, Status> {
+        let OperatePopupRequest {
+            popup_id,
+            operation,
+        } = request.into_inner();
+
+        let id = PopupId(popup_id);
+
+        run_unary(&self.sender, move |state| {
+            let Some(popup) = state.popup_for_id(id) else {
+                return Ok(OperatePopupResponse {});
+            };
+
+            let Some(operation) = operation else {
+                return Ok(OperatePopupResponse {});
+            };
+
+            let operation =
+                Box::try_from_api(operation).context("While processing OperatePopupRequest");
+            let mut operation = match operation {
+                Err(e) => {
+                    tracing::error!("{e:?}");
+                    return Ok(OperatePopupResponse {});
+                }
+                Ok(o) => o,
+            };
+
+            popup.operate(&mut operation);
+
+            Ok(OperatePopupResponse {})
+        })
+        .await
+    }
+
+    async fn update_popup(
+        &self,
+        request: Request<UpdatePopupRequest>,
+    ) -> Result<Response<UpdatePopupResponse>, Status> {
+        let request = request.into_inner();
+
+        let id = request.popup_id;
+        let id = PopupId(id);
+
+        let position = request.position.clone().map(popup::Position::from);
+        let anchor = Option::from_api(request.anchor());
+        let gravity = Option::from_api(request.gravity());
+        let offset = request.offset.map(popup::Offset::from);
+        let constraints_adjust = request
+            .constraints_adjust
+            .map(xdg_positioner::ConstraintAdjustment::from_api);
+
+        let widget_def = request.widget_def;
+
+        run_unary(&self.sender, move |state| {
+            let mut new_anchor_rect = None;
+
+            let Some(parent_id) = state.popup_for_id(id).map(|p| p.parent_id) else {
+                return Ok(UpdatePopupResponse {});
+            };
+
+            if let Some(position) = position {
+                let anchor_rect = match parent_id {
+                    popup::ParentId::Popup(id) => {
+                        let p = state
+                            .popups
+                            .iter_mut()
+                            .find(|p| p.popup_id == id)
+                            .ok_or(Status::internal("parent not found."))?;
+
+                        position
+                            .anchor_rect_for(&mut p.surface)
+                            .ok_or(Status::invalid_argument("invalid position."))?
+                    }
+                    popup::ParentId::Layer(id) => {
+                        let l = state
+                            .layers
+                            .iter_mut()
+                            .find(|l| l.layer_id == id)
+                            .ok_or(Status::internal("parent not found."))?;
+
+                        position
+                            .anchor_rect_for(&mut l.surface)
+                            .ok_or(Status::invalid_argument("invalid position."))?
+                    }
+                    // Decoration as parent is not implemented at the moment.
+                    popup::ParentId::Decoration(_) => unreachable!(),
+                };
+
+                new_anchor_rect = Some(anchor_rect);
+            }
+
+            let Some(popup) = state.popup_for_id(id) else {
+                return Ok(UpdatePopupResponse {});
+            };
+
+            popup.update_properties(
+                new_anchor_rect,
+                anchor,
+                gravity,
+                offset,
+                constraints_adjust,
+                widget_def.and_then(widget_def_to_fn),
+            );
+
+            Ok(UpdatePopupResponse {})
+        })
+        .await
+    }
+
+    async fn request_view(
+        &self,
+        request: Request<ViewRequest>,
+    ) -> Result<Response<ViewResponse>, Status> {
+        let request = request.into_inner();
+
+        let id = request.popup_id;
+        let id = PopupId(id);
+
+        run_unary(&self.sender, move |state| {
+            let Some(popup) = state.popups.iter_mut().find(|p| p.popup_id == id) else {
+                return Ok(ViewResponse {});
+            };
+
+            popup.request_view();
+            popup.schedule_redraw();
+
+            Ok(ViewResponse {})
+        })
+        .await
+    }
+}
+
+impl From<new_popup_request::ParentId> for popup::ParentId {
+    fn from(value: new_popup_request::ParentId) -> Self {
+        use new_popup_request::ParentId;
+        match value {
+            ParentId::LayerId(id) => popup::ParentId::Layer(LayerId(id)),
+            ParentId::DecoId(id) => popup::ParentId::Decoration(DecorationId(id)),
+            ParentId::PopupId(id) => popup::ParentId::Popup(PopupId(id)),
+        }
+    }
+}
+
+impl From<v1::Position> for popup::Position {
+    fn from(value: v1::Position) -> Self {
+        use v1::position::Strategy;
+
+        let Some(strategy) = value.strategy else {
+            return popup::Position::AtCursor;
+        };
+
+        match strategy {
+            Strategy::AtCursor(_) => popup::Position::AtCursor,
+            Strategy::Absolute(v1::Rectangle {
+                x,
+                y,
+                width,
+                height,
+            }) => popup::Position::Absolute {
+                x,
+                y,
+                width,
+                height,
+            },
+            Strategy::AtWidget(id) => popup::Position::Widget(id),
+        }
+    }
+}
+
+impl From<v1::Offset> for popup::Offset {
+    fn from(value: v1::Offset) -> Self {
+        let v1::Offset { x, y } = value;
+
+        popup::Offset {
+            x: x as i32,
+            y: y as i32,
+        }
+    }
+}
+
+impl FromApi<v1::Anchor> for Option<xdg_positioner::Anchor> {
+    fn from_api(value: v1::Anchor) -> Self {
+        use v1::Anchor;
+
+        let ret = match value {
+            Anchor::Unspecified => return None,
+            Anchor::Top => xdg_positioner::Anchor::Top,
+            Anchor::Bottom => xdg_positioner::Anchor::Bottom,
+            Anchor::Left => xdg_positioner::Anchor::Left,
+            Anchor::Right => xdg_positioner::Anchor::Right,
+            Anchor::TopLeft => xdg_positioner::Anchor::TopLeft,
+            Anchor::BottomLeft => xdg_positioner::Anchor::BottomLeft,
+            Anchor::TopRight => xdg_positioner::Anchor::TopRight,
+            Anchor::BottomRight => xdg_positioner::Anchor::BottomRight,
+            Anchor::None => xdg_positioner::Anchor::None,
+        };
+
+        Some(ret)
+    }
+}
+
+impl FromApi<v1::Gravity> for Option<xdg_positioner::Gravity> {
+    fn from_api(value: v1::Gravity) -> Self {
+        use v1::Gravity;
+
+        let ret = match value {
+            Gravity::Unspecified => return None,
+            Gravity::Top => xdg_positioner::Gravity::Top,
+            Gravity::Bottom => xdg_positioner::Gravity::Bottom,
+            Gravity::Left => xdg_positioner::Gravity::Left,
+            Gravity::Right => xdg_positioner::Gravity::Right,
+            Gravity::TopLeft => xdg_positioner::Gravity::TopLeft,
+            Gravity::BottomLeft => xdg_positioner::Gravity::BottomLeft,
+            Gravity::TopRight => xdg_positioner::Gravity::TopRight,
+            Gravity::BottomRight => xdg_positioner::Gravity::BottomRight,
+            Gravity::None => xdg_positioner::Gravity::None,
+        };
+
+        Some(ret)
+    }
+}
+
+impl FromApi<v1::ConstraintsAdjust> for xdg_positioner::ConstraintAdjustment {
+    fn from_api(api_type: v1::ConstraintsAdjust) -> Self {
+        let v1::ConstraintsAdjust {
+            none,
+            slide_x,
+            slide_y,
+            flip_x,
+            flip_y,
+            resize_x,
+            resize_y,
+        } = api_type;
+
+        let mut ret = Self::None;
+
+        if none {
+            return ret;
+        };
+
+        if slide_x {
+            ret |= Self::SlideX;
+        }
+
+        if slide_y {
+            ret |= Self::SlideY;
+        }
+
+        if flip_x {
+            ret |= Self::FlipX;
+        }
+
+        if flip_y {
+            ret |= Self::FlipY;
+        }
+
+        if resize_x {
+            ret |= Self::ResizeX;
+        }
+
+        if resize_y {
+            ret |= Self::ResizeY;
+        }
+
+        ret
+    }
+}
diff --git a/snowcap/src/api/widget/v1.rs b/snowcap/src/api/widget/v1.rs
index a1c9b46ca..58dd5950b 100644
--- a/snowcap/src/api/widget/v1.rs
+++ b/snowcap/src/api/widget/v1.rs
@@ -15,6 +15,7 @@ use crate::{
     api::{ResponseStream, run_server_streaming_mapped},
     decoration::DecorationId,
     layer::LayerId,
+    popup::PopupId,
     util::convert::{FromApi, TryFromApi},
     widget::{MouseAreaEvent, TextInputEvent, ViewFn, WidgetEvent, WidgetId},
 };
@@ -44,6 +45,11 @@ impl widget_service_server::WidgetService for super::WidgetService {
                         deco.surface.widget_event_sender = Some(sender);
                     }
                 }
+                get_widget_events_request::Id::PopupId(popup_id) => {
+                    if let Some(popup) = state.popup_for_id(PopupId(popup_id)) {
+                        popup.surface.widget_event_sender = Some(sender);
+                    }
+                }
             },
             |events| {
                 Ok(GetWidgetEventsResponse {
@@ -409,6 +415,7 @@ pub fn widget_def_to_fn(def: WidgetDef) -> Option<ViewFn> {
                 clip,
                 child,
                 style,
+                id,
             } = *container_def;
 
             let child_widget_fn = child.and_then(|def| widget_def_to_fn(*def));
@@ -499,6 +506,10 @@ pub fn widget_def_to_fn(def: WidgetDef) -> Option<ViewFn> {
 
                 container = container.style(style);
 
+                if let Some(id) = id.clone() {
+                    container = container.id(id);
+                }
+
                 container.into()
             });
 
diff --git a/snowcap/src/handlers.rs b/snowcap/src/handlers.rs
index fb133ed4e..a105ea485 100644
--- a/snowcap/src/handlers.rs
+++ b/snowcap/src/handlers.rs
@@ -7,6 +7,7 @@ pub mod pointer;
 use smithay_client_toolkit::{
     compositor::CompositorHandler,
     delegate_compositor, delegate_layer, delegate_output, delegate_registry, delegate_seat,
+    delegate_xdg_popup, delegate_xdg_shell,
     output::{OutputHandler, OutputState},
     reexports::{
         client::{
@@ -32,6 +33,10 @@ use smithay_client_toolkit::{
     shell::{
         WaylandSurface,
         wlr_layer::{LayerShellHandler, LayerSurface, LayerSurfaceConfigure},
+        xdg::{
+            popup::{self, PopupHandler},
+            window::WindowHandler,
+        },
     },
 };
 
@@ -51,8 +56,13 @@ impl SeatHandler for State {
         &mut self.seat_state
     }
 
-    fn new_seat(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _seat: WlSeat) {
-        // TODO:
+    fn new_seat(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, seat: WlSeat) {
+        // TODO: For now we only support one seat. This is good enough as most compositor only
+        // support one seat as well, but could be improved either by picking the best seat (the one
+        // with the most desirable capabilities), or having the user pick a seat by name.
+        if self.seat.is_none() {
+            self.seat = Some(seat);
+        }
     }
 
     fn new_capability(
@@ -134,18 +144,47 @@ impl OutputHandler for State {
             layer.output_size_changed(iced::Size::new(size.0 as u32, size.1 as u32));
             layer.surface.request_frame();
         }
+
+        for popup in self
+            .popups
+            .iter_mut()
+            .filter(|p| p.wl_output.as_ref() == Some(&output))
+        {
+            popup.output_size_changed(iced::Size::new(size.0 as u32, size.1 as u32));
+            popup.surface.request_frame();
+        }
     }
 
     fn output_destroyed(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, output: WlOutput) {
-        self.layers
-            .retain(|layer| layer.wl_output.as_ref() != Some(&output));
+        let to_delete: Vec<_> = self
+            .layers
+            .iter()
+            .filter_map(|layer| {
+                if layer.wl_output.as_ref() == Some(&output) {
+                    Some(layer.layer_id)
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        for layer_id in to_delete {
+            self.layer_destroy(layer_id);
+        }
     }
 }
 delegate_output!(State);
 
 impl LayerShellHandler for State {
     fn closed(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, layer: &LayerSurface) {
-        self.layers.retain(|sn_layer| &sn_layer.layer != layer);
+        if let Some(layer_id) = self
+            .layers
+            .iter()
+            .find(|l| &l.layer == layer)
+            .map(|l| l.layer_id)
+        {
+            self.layer_destroy(layer_id);
+        }
     }
 
     fn configure(
@@ -219,6 +258,16 @@ impl CompositorHandler for State {
 
         if let Some(deco) = deco {
             deco.schedule_redraw();
+            return;
+        }
+
+        let popup = self
+            .popups
+            .iter_mut()
+            .find(|popup| popup.popup.wl_surface() == surface);
+
+        if let Some(popup) = popup {
+            popup.schedule_redraw();
         }
     }
 
@@ -229,16 +278,6 @@ impl CompositorHandler for State {
         surface: &WlSurface,
         output: &wl_output::WlOutput,
     ) {
-        let Some(layer) = self
-            .layers
-            .iter_mut()
-            .find(|layer| layer.layer.wl_surface() == surface)
-        else {
-            return;
-        };
-
-        layer.wl_output = Some(output.clone());
-
         let Some(output_info) = self.output_state.info(output) else {
             return;
         };
@@ -249,19 +288,39 @@ impl CompositorHandler for State {
 
         let size = iced::Size::new(size.0 as u32, size.1 as u32);
 
-        if let InitialConfigureState::PreConfigure(pending) = &mut layer.initial_configure {
-            *pending = Some(size);
-            return;
-        }
+        if let Some(layer) = self
+            .layers
+            .iter_mut()
+            .find(|layer| layer.layer.wl_surface() == surface)
+        {
+            layer.wl_output = Some(output.clone());
 
-        if layer.initial_configure == InitialConfigureState::PostConfigure {
-            return;
-        };
+            if let InitialConfigureState::PreConfigure(pending) = &mut layer.initial_configure {
+                *pending = Some(size);
+                return;
+            }
 
-        layer.initial_configure = InitialConfigureState::PostOutputSize;
+            if layer.initial_configure == InitialConfigureState::PostConfigure {
+                return;
+            };
 
-        layer.output_size_changed(size);
-        layer.surface.request_frame();
+            layer.initial_configure = InitialConfigureState::PostOutputSize;
+
+            layer.output_size_changed(size);
+            layer.surface.request_frame();
+        } else if let Some(popup) = self
+            .popups
+            .iter_mut()
+            .find(|p| p.popup.wl_surface() == surface)
+        {
+            popup.wl_output = Some(output.clone());
+
+            popup.output_size_changed(size);
+
+            if popup.initial_configure_received {
+                popup.surface.request_frame()
+            }
+        }
     }
 
     fn surface_leave(
@@ -289,30 +348,105 @@ impl Dispatch<WpFractionalScaleV1, WlSurface> for State {
         _conn: &Connection,
         _qhandle: &QueueHandle<Self>,
     ) {
-        if let Some(layer) = state
+        let surface = if let Some(layer) = state
             .layers
             .iter_mut()
             .find(|layer| layer.layer.wl_surface() == surface)
         {
-            match event {
-                wp_fractional_scale_v1::Event::PreferredScale { scale } => {
-                    layer.surface.scale_changed(scale as f32 / 120.0);
-                    layer.surface.request_frame();
-                }
-                _ => unreachable!(),
-            }
+            &mut layer.surface
         } else if let Some(deco) = state
             .decorations
             .iter_mut()
             .find(|deco| &deco.surface.wl_surface == surface)
         {
-            match event {
-                wp_fractional_scale_v1::Event::PreferredScale { scale } => {
-                    deco.surface.scale_changed(scale as f32 / 120.0);
-                    deco.surface.request_frame();
-                }
-                _ => unreachable!(),
+            &mut deco.surface
+        } else if let Some(popup) = state
+            .popups
+            .iter_mut()
+            .find(|popup| &popup.surface.wl_surface == surface)
+        {
+            &mut popup.surface
+        } else {
+            return;
+        };
+
+        match event {
+            wp_fractional_scale_v1::Event::PreferredScale { scale } => {
+                surface.scale_changed(scale as f32 / 120.0);
+                surface.request_frame();
             }
+            _ => unreachable!(),
         }
     }
 }
+
+impl WindowHandler for State {
+    fn configure(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _window: &smithay_client_toolkit::shell::xdg::window::Window,
+        _configure: smithay_client_toolkit::shell::xdg::window::WindowConfigure,
+        _serial: u32,
+    ) {
+        unimplemented!()
+    }
+
+    fn request_close(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _window: &smithay_client_toolkit::shell::xdg::window::Window,
+    ) {
+        unimplemented!()
+    }
+}
+
+delegate_xdg_shell!(State);
+
+impl PopupHandler for State {
+    fn configure(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        popup: &smithay_client_toolkit::shell::xdg::popup::Popup,
+        config: smithay_client_toolkit::shell::xdg::popup::PopupConfigure,
+    ) {
+        let Some(popup) = self.popups.iter_mut().find(|p| &p.popup == popup) else {
+            return;
+        };
+
+        popup.size_changed(iced::Size::new(config.width as u32, config.height as u32));
+
+        match config.kind {
+            popup::ConfigureKind::Initial => {
+                popup.initial_configure_received = true;
+                popup.schedule_redraw();
+            }
+            popup::ConfigureKind::Reposition { token } => {
+                popup.repositioned(Some(token));
+            }
+            popup::ConfigureKind::Reactive => {
+                popup.repositioned(None);
+            }
+            _ => unreachable!(),
+        };
+    }
+
+    fn done(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        popup: &smithay_client_toolkit::shell::xdg::popup::Popup,
+    ) {
+        if let Some(popup_id) = self
+            .popups
+            .iter()
+            .find(|p| &p.popup == popup)
+            .map(|p| p.popup_id)
+        {
+            self.popup_destroy(popup_id);
+        };
+    }
+}
+delegate_xdg_popup!(State);
diff --git a/snowcap/src/handlers/keyboard.rs b/snowcap/src/handlers/keyboard.rs
index 3c8302052..4642bcc52 100644
--- a/snowcap/src/handlers/keyboard.rs
+++ b/snowcap/src/handlers/keyboard.rs
@@ -6,7 +6,7 @@ use smithay_client_toolkit::{
         protocol::{wl_keyboard::WlKeyboard, wl_surface::WlSurface},
     },
     seat::keyboard::{KeyEvent, KeyboardHandler, Keysym, Modifiers, RawModifiers},
-    shell::{WaylandSurface, wlr_layer::LayerSurface},
+    shell::{WaylandSurface, wlr_layer::LayerSurface, xdg::popup::Popup},
 };
 
 use crate::{input::keyboard::keysym_to_iced_key_and_loc, state::State};
@@ -22,18 +22,38 @@ pub struct KeyboardKey {
 
 impl State {
     pub(crate) fn on_key_repeat(&mut self, keyboard: &WlKeyboard, event: KeyEvent) {
-        self.on_key_press(keyboard, event, true);
+        self.on_key_press(keyboard, event, true, None);
     }
 
-    pub(crate) fn on_key_press(&mut self, _keyboard: &WlKeyboard, event: KeyEvent, repeat: bool) {
-        let Some(KeyboardFocus::Layer(layer)) = self.keyboard_focus.as_ref() else {
-            return;
+    pub(crate) fn on_key_press(
+        &mut self,
+        _keyboard: &WlKeyboard,
+        event: KeyEvent,
+        repeat: bool,
+        serial: Option<u32>,
+    ) {
+        let surface = match self.keyboard_focus.as_ref() {
+            Some(KeyboardFocus::Layer(layer)) => self
+                .layers
+                .iter_mut()
+                .find(|l| &l.layer == layer)
+                .map(|l| &mut l.surface),
+            Some(KeyboardFocus::Popup(popup)) => self
+                .popups
+                .iter_mut()
+                .find(|l| &l.popup == popup)
+                .map(|l| &mut l.surface),
+            _ => None,
         };
 
-        let Some(snowcap_layer) = self.layers.iter_mut().find(|sn_l| &sn_l.layer == layer) else {
+        let Some(surface) = surface else {
             return;
         };
 
+        if let Some(serial) = serial {
+            surface.focus_serial = Some(serial);
+        }
+
         let (key, location) = keysym_to_iced_key_and_loc(event.keysym);
 
         let mut modifiers = iced::keyboard::Modifiers::empty();
@@ -50,8 +70,7 @@ impl State {
             modifiers |= iced::keyboard::Modifiers::LOGO;
         }
 
-        snowcap_layer
-            .surface
+        surface
             .widgets
             .queue_event(iced::Event::Keyboard(iced::keyboard::Event::KeyPressed {
                 key: key.clone(),
@@ -72,16 +91,24 @@ impl KeyboardHandler for State {
         _qh: &QueueHandle<Self>,
         _keyboard: &WlKeyboard,
         surface: &WlSurface,
-        _serial: u32,
+        serial: u32,
         _raw: &[u32],
         _keysyms: &[Keysym],
     ) {
         if let Some(layer) = self
             .layers
-            .iter()
+            .iter_mut()
             .find(|sn_layer| sn_layer.layer.wl_surface() == surface)
         {
+            layer.surface.focus_serial = Some(serial);
             self.keyboard_focus = Some(KeyboardFocus::Layer(layer.layer.clone()));
+        } else if let Some(popup) = self
+            .popups
+            .iter_mut()
+            .find(|p| p.popup.wl_surface() == surface)
+        {
+            popup.surface.focus_serial = Some(serial);
+            self.keyboard_focus = Some(KeyboardFocus::Popup(popup.popup.clone()))
         }
     }
 
@@ -93,11 +120,15 @@ impl KeyboardHandler for State {
         surface: &WlSurface,
         _serial: u32,
     ) {
-        if let Some(KeyboardFocus::Layer(layer)) = self.keyboard_focus.as_ref()
-            && layer.wl_surface() == surface
-        {
-            self.keyboard_focus = None;
-        }
+        match self.keyboard_focus.as_ref() {
+            Some(KeyboardFocus::Layer(layer)) if layer.wl_surface() == surface => {
+                self.keyboard_focus = None;
+            }
+            Some(KeyboardFocus::Popup(popup)) if popup.wl_surface() == surface => {
+                self.keyboard_focus = None
+            }
+            _ => (),
+        };
     }
 
     fn press_key(
@@ -105,10 +136,10 @@ impl KeyboardHandler for State {
         _conn: &Connection,
         _qh: &QueueHandle<Self>,
         keyboard: &WlKeyboard,
-        _serial: u32,
+        serial: u32,
         event: KeyEvent,
     ) {
-        self.on_key_press(keyboard, event, false)
+        self.on_key_press(keyboard, event, false, Some(serial))
     }
 
     fn release_key(
@@ -116,17 +147,29 @@ impl KeyboardHandler for State {
         _conn: &Connection,
         _qh: &QueueHandle<Self>,
         _keyboard: &WlKeyboard,
-        _serial: u32,
+        serial: u32,
         event: KeyEvent,
     ) {
-        let Some(KeyboardFocus::Layer(layer)) = self.keyboard_focus.as_ref() else {
-            return;
+        let surface = match self.keyboard_focus.as_ref() {
+            Some(KeyboardFocus::Layer(layer)) => self
+                .layers
+                .iter_mut()
+                .find(|l| &l.layer == layer)
+                .map(|l| &mut l.surface),
+            Some(KeyboardFocus::Popup(popup)) => self
+                .popups
+                .iter_mut()
+                .find(|l| &l.popup == popup)
+                .map(|l| &mut l.surface),
+            _ => None,
         };
 
-        let Some(snowcap_layer) = self.layers.iter_mut().find(|sn_l| &sn_l.layer == layer) else {
+        let Some(surface) = surface else {
             return;
         };
 
+        surface.focus_serial = Some(serial);
+
         let (key, location) = keysym_to_iced_key_and_loc(event.keysym);
 
         let mut modifiers = iced::keyboard::Modifiers::empty();
@@ -143,8 +186,7 @@ impl KeyboardHandler for State {
             modifiers |= iced::keyboard::Modifiers::LOGO;
         }
 
-        snowcap_layer
-            .surface
+        surface
             .widgets
             .queue_event(iced::Event::Keyboard(iced::keyboard::Event::KeyReleased {
                 key: key.clone(),
@@ -161,22 +203,33 @@ impl KeyboardHandler for State {
         _conn: &Connection,
         _qh: &QueueHandle<Self>,
         _keyboard: &WlKeyboard,
-        _serial: u32,
+        serial: u32,
         modifiers: Modifiers,
         _raw_modifiers: RawModifiers,
         _layout: u32,
     ) {
         self.keyboard_modifiers = modifiers;
 
-        // TODO: Should we check if the modifiers actually changed ?
-        let Some(KeyboardFocus::Layer(layer)) = self.keyboard_focus.as_ref() else {
-            return;
+        let surface = match self.keyboard_focus.as_ref() {
+            Some(KeyboardFocus::Layer(layer)) => self
+                .layers
+                .iter_mut()
+                .find(|l| &l.layer == layer)
+                .map(|l| &mut l.surface),
+            Some(KeyboardFocus::Popup(popup)) => self
+                .popups
+                .iter_mut()
+                .find(|l| &l.popup == popup)
+                .map(|l| &mut l.surface),
+            _ => None,
         };
 
-        let Some(snowcap_layer) = self.layers.iter_mut().find(|sn_l| &sn_l.layer == layer) else {
+        let Some(surface) = surface else {
             return;
         };
 
+        surface.focus_serial = Some(serial);
+
         let mut modifiers = iced::keyboard::Modifiers::empty();
         if self.keyboard_modifiers.ctrl {
             modifiers |= iced::keyboard::Modifiers::CTRL;
@@ -191,12 +244,9 @@ impl KeyboardHandler for State {
             modifiers |= iced::keyboard::Modifiers::LOGO;
         }
 
-        snowcap_layer
-            .surface
-            .widgets
-            .queue_event(iced::Event::Keyboard(
-                iced::keyboard::Event::ModifiersChanged(modifiers),
-            ));
+        surface.widgets.queue_event(iced::Event::Keyboard(
+            iced::keyboard::Event::ModifiersChanged(modifiers),
+        ));
     }
 
     fn repeat_key(
@@ -212,11 +262,12 @@ impl KeyboardHandler for State {
         // I'm leaving this commented for now because I don't know whether only one or both
         // function will get called when support is added.
         //
-        // self.on_key_repeat(keyboard, event, true)
+        // self.on_key_repeat(keyboard, event, true, Some(serial))
     }
 }
 delegate_keyboard!(State);
 
 pub enum KeyboardFocus {
     Layer(LayerSurface),
+    Popup(Popup),
 }
diff --git a/snowcap/src/handlers/pointer.rs b/snowcap/src/handlers/pointer.rs
index 991b1414c..388bfbc5c 100644
--- a/snowcap/src/handlers/pointer.rs
+++ b/snowcap/src/handlers/pointer.rs
@@ -6,7 +6,6 @@ use smithay_client_toolkit::{
         protocol::wl_pointer::{AxisSource, WlPointer},
     },
     seat::pointer::{PointerEvent, PointerEventKind, PointerHandler},
-    shell::WaylandSurface,
 };
 
 use crate::state::State;
@@ -20,38 +19,22 @@ impl PointerHandler for State {
         events: &[PointerEvent],
     ) {
         for event in events {
-            let mut layer = self
-                .layers
-                .iter_mut()
-                .find(|sn_layer| sn_layer.layer.wl_surface() == &event.surface);
-            let mut deco = self
-                .decorations
-                .iter_mut()
-                .find(|deco| deco.surface.wl_surface == event.surface);
+            let Some(surface) = self.find_surface_mut(&event.surface) else {
+                return;
+            };
 
             let iced_event = match event.kind {
-                PointerEventKind::Enter { serial: _ } => {
-                    if let Some(layer) = layer.as_mut() {
-                        layer.surface.pointer_location = Some(event.position);
-                    } else if let Some(deco) = deco.as_mut() {
-                        deco.surface.pointer_location = Some(event.position);
-                    }
+                PointerEventKind::Enter { serial } => {
+                    surface.pointer_location = Some(event.position);
+                    surface.focus_serial = Some(serial);
                     iced::Event::Mouse(iced::mouse::Event::CursorEntered)
                 }
                 PointerEventKind::Leave { serial: _ } => {
-                    if let Some(layer) = layer.as_mut() {
-                        layer.surface.pointer_location = None;
-                    } else if let Some(deco) = deco.as_mut() {
-                        deco.surface.pointer_location = None;
-                    }
+                    surface.pointer_location = None;
                     iced::Event::Mouse(iced::mouse::Event::CursorLeft)
                 }
                 PointerEventKind::Motion { time: _ } => {
-                    if let Some(layer) = layer.as_mut() {
-                        layer.surface.pointer_location = Some(event.position);
-                    } else if let Some(deco) = deco.as_mut() {
-                        deco.surface.pointer_location = Some(event.position);
-                    }
+                    surface.pointer_location = Some(event.position);
                     iced::Event::Mouse(iced::mouse::Event::CursorMoved {
                         position: iced::Point {
                             x: event.position.0 as f32,
@@ -62,17 +45,23 @@ impl PointerHandler for State {
                 PointerEventKind::Press {
                     time: _,
                     button,
-                    serial: _,
-                } => iced::Event::Mouse(iced::mouse::Event::ButtonPressed(button_to_iced_button(
-                    button,
-                ))),
+                    serial,
+                } => {
+                    surface.focus_serial = Some(serial);
+                    iced::Event::Mouse(iced::mouse::Event::ButtonPressed(button_to_iced_button(
+                        button,
+                    )))
+                }
                 PointerEventKind::Release {
                     time: _,
                     button,
-                    serial: _,
-                } => iced::Event::Mouse(iced::mouse::Event::ButtonReleased(button_to_iced_button(
-                    button,
-                ))),
+                    serial,
+                } => {
+                    surface.focus_serial = Some(serial);
+                    iced::Event::Mouse(iced::mouse::Event::ButtonReleased(button_to_iced_button(
+                        button,
+                    )))
+                }
                 PointerEventKind::Axis {
                     time: _,
                     horizontal,
@@ -97,11 +86,7 @@ impl PointerHandler for State {
                 }
             };
 
-            if let Some(layer) = layer.as_mut() {
-                layer.surface.widgets.queue_event(iced_event);
-            } else if let Some(deco) = deco.as_mut() {
-                deco.surface.widgets.queue_event(iced_event);
-            }
+            surface.widgets.queue_event(iced_event);
         }
     }
 }
diff --git a/snowcap/src/layer.rs b/snowcap/src/layer.rs
index ea9af6d39..30af6e47d 100644
--- a/snowcap/src/layer.rs
+++ b/snowcap/src/layer.rs
@@ -13,7 +13,8 @@ use tokio::sync::mpsc::UnboundedSender;
 use tonic::Status;
 
 use crate::{
-    handlers::keyboard::KeyboardKey, state::State, surface::SnowcapSurface, widget::ViewFn,
+    handlers::keyboard::KeyboardKey, popup::ParentId, state::State, surface::SnowcapSurface,
+    widget::ViewFn,
 };
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Default)]
@@ -35,6 +36,26 @@ impl State {
     pub fn layer_for_id(&mut self, id: LayerId) -> Option<&mut SnowcapLayer> {
         self.layers.iter_mut().find(|layer| layer.layer_id == id)
     }
+
+    pub fn layer_destroy(&mut self, id: LayerId) {
+        let to_destroy: Vec<_> = self
+            .popups
+            .iter()
+            .filter_map(|p| {
+                if p.parent_id == ParentId::Layer(id) {
+                    Some(p.popup_id)
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        for popup_id in to_destroy {
+            self.popup_destroy(popup_id);
+        }
+
+        self.layers.retain(|p| p.layer_id != id);
+    }
 }
 
 pub struct SnowcapLayer {
diff --git a/snowcap/src/lib.rs b/snowcap/src/lib.rs
index 446d9763e..16cb69c1c 100644
--- a/snowcap/src/lib.rs
+++ b/snowcap/src/lib.rs
@@ -5,6 +5,7 @@ pub mod decoration;
 pub mod handlers;
 pub mod input;
 pub mod layer;
+pub mod popup;
 pub mod runtime;
 pub mod server;
 pub mod state;
@@ -64,6 +65,7 @@ pub fn start(stop_signal_sender: Option<tokio::sync::oneshot::Sender<SnowcapHand
             .insert_source(close_ping_source, move |_, _, state| {
                 state.layers.clear();
                 state.decorations.clear();
+                state.popups.clear();
             })
             .unwrap();
 
@@ -87,6 +89,9 @@ pub fn start(stop_signal_sender: Option<tokio::sync::oneshot::Sender<SnowcapHand
                         handlers::keyboard::KeyboardFocus::Layer(layer) => {
                             !state.layers.iter().any(|sn_layer| &sn_layer.layer == layer)
                         }
+                        handlers::keyboard::KeyboardFocus::Popup(popup) => {
+                            !state.popups.iter().any(|p| &p.popup == popup)
+                        }
                     });
             if keyboard_focus_is_dead {
                 state.keyboard_focus = None;
@@ -103,6 +108,11 @@ pub fn start(stop_signal_sender: Option<tokio::sync::oneshot::Sender<SnowcapHand
                 deco.update(&mut state.runtime, state.tiny_skia.as_mut().unwrap());
                 deco.draw_if_scheduled();
             }
+
+            for popup in state.popups.iter_mut() {
+                popup.update(&mut state.runtime, state.compositor.as_mut().unwrap());
+                popup.draw_if_scheduled();
+            }
         })
         .unwrap();
 }
diff --git a/snowcap/src/popup.rs b/snowcap/src/popup.rs
new file mode 100644
index 000000000..3b6406942
--- /dev/null
+++ b/snowcap/src/popup.rs
@@ -0,0 +1,562 @@
+use iced_runtime::core::widget::{
+    self,
+    operation::{self, Operation, Outcome},
+};
+use smithay_client_toolkit::{
+    reexports::{
+        client::protocol::wl_output::WlOutput,
+        protocols::xdg::shell::client::xdg_positioner::{self, ConstraintAdjustment},
+    },
+    shell::xdg::{XdgPositioner, popup::Popup},
+};
+use tokio::sync::mpsc::UnboundedSender;
+
+use crate::{
+    decoration::DecorationId, handlers::keyboard::KeyboardKey, layer::LayerId, state::State,
+    surface::SnowcapSurface, widget::ViewFn,
+};
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Default)]
+pub struct PopupId(pub u32);
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Default)]
+pub struct PopupIdCounter(PopupId);
+
+impl PopupIdCounter {
+    #[allow(clippy::should_implement_trait)]
+    pub fn next(&mut self) -> PopupId {
+        let ret = self.0;
+        self.0.0 += 1;
+        ret
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+pub enum ParentId {
+    Layer(LayerId),
+    Decoration(DecorationId),
+    Popup(PopupId),
+}
+
+impl State {
+    pub fn popup_for_id(&mut self, id: PopupId) -> Option<&mut SnowcapPopup> {
+        self.popups.iter_mut().find(|popup| popup.popup_id == id)
+    }
+
+    pub fn popup_destroy(&mut self, id: PopupId) {
+        let mut to_destroy = vec![id];
+
+        while let Some(destroy_first) = to_destroy.last().and_then(|id| {
+            self.popups
+                .iter()
+                .find(|p| p.parent_id == ParentId::Popup(*id))
+        }) {
+            to_destroy.push(destroy_first.popup_id)
+        }
+
+        for popup_id in to_destroy.iter().rev() {
+            self.popups.retain(|p| &p.popup_id != popup_id)
+        }
+    }
+}
+
+pub struct Offset {
+    pub x: i32,
+    pub y: i32,
+}
+
+pub enum Position {
+    AtCursor,
+    Absolute {
+        x: f32,
+        y: f32,
+        width: f32,
+        height: f32,
+    },
+    Widget(String),
+}
+
+impl Position {
+    pub fn anchor_rect_for(&self, surface: &mut SnowcapSurface) -> Option<iced::Rectangle<i32>> {
+        match self {
+            Position::AtCursor => surface.pointer_location.map(|(x, y)| iced::Rectangle {
+                x: x as i32,
+                y: y as i32,
+                width: 1,
+                height: 1,
+            }),
+            &Position::Absolute {
+                x,
+                y,
+                width,
+                height,
+            } => {
+                let size = surface.widgets.size();
+                let bounds = iced::Rectangle::with_size(size);
+                let anchor = iced::Rectangle {
+                    x,
+                    y,
+                    width,
+                    height,
+                };
+
+                if anchor.is_within(&bounds.into()) {
+                    Some(iced::Rectangle {
+                        x: x as i32,
+                        y: y as i32,
+                        width: width as i32,
+                        height: height as i32,
+                    })
+                } else {
+                    None
+                }
+            }
+            Position::Widget(id) => {
+                let mut ope = get_bounds(id.clone().into());
+
+                {
+                    let mut black_box = operation::black_box(&mut ope);
+
+                    surface.operate(&mut black_box);
+                }
+
+                match ope.finish() {
+                    Outcome::Some(bounds) => Some(bounds),
+                    Outcome::None => None,
+                    _ => unreachable!(),
+                }
+                .map(|b| {
+                    let iced::Rectangle {
+                        x,
+                        y,
+                        width,
+                        height,
+                    } = b;
+                    iced::Rectangle {
+                        x: x as i32,
+                        y: y as i32,
+                        width: width as i32,
+                        height: height as i32,
+                    }
+                })
+            }
+        }
+    }
+}
+
+pub fn get_bounds(target: widget::Id) -> impl Operation<iced::Rectangle> {
+    struct GetBounds {
+        target: widget::Id,
+        bounds: Option<iced::Rectangle>,
+    }
+
+    impl Operation<iced::Rectangle> for GetBounds {
+        fn container(&mut self, id: Option<&widget::Id>, bounds: iced::Rectangle) {
+            if id.is_some_and(|id| *id == self.target) {
+                self.bounds = Some(bounds);
+            }
+        }
+
+        fn text(&mut self, id: Option<&widget::Id>, bounds: iced::Rectangle, _text: &str) {
+            if id.is_some_and(|id| *id == self.target) {
+                self.bounds = Some(bounds);
+            }
+        }
+
+        fn custom(
+            &mut self,
+            id: Option<&widget::Id>,
+            bounds: iced::Rectangle,
+            _state: &mut dyn std::any::Any,
+        ) {
+            if id.is_some_and(|id| *id == self.target) {
+                self.bounds = Some(bounds);
+            }
+        }
+
+        fn focusable(
+            &mut self,
+            id: Option<&widget::Id>,
+            bounds: iced::Rectangle,
+            _state: &mut dyn widget::operation::Focusable,
+        ) {
+            if id.is_some_and(|id| *id == self.target) {
+                self.bounds = Some(bounds);
+            }
+        }
+
+        fn scrollable(
+            &mut self,
+            id: Option<&widget::Id>,
+            bounds: iced::Rectangle,
+            _content_bounds: iced::Rectangle,
+            _translation: iced::Vector,
+            _state: &mut dyn widget::operation::Scrollable,
+        ) {
+            if id.is_some_and(|id| *id == self.target) {
+                self.bounds = Some(bounds);
+            }
+        }
+
+        fn text_input(
+            &mut self,
+            id: Option<&widget::Id>,
+            bounds: iced::Rectangle,
+            _state: &mut dyn widget::operation::TextInput,
+        ) {
+            if id.is_some_and(|id| *id == self.target) {
+                self.bounds = Some(bounds);
+            }
+        }
+
+        fn traverse(&mut self, operate: &mut dyn FnMut(&mut dyn Operation<iced::Rectangle>)) {
+            if self.bounds.is_some() {
+                return;
+            }
+
+            operate(self);
+        }
+
+        fn finish(&self) -> Outcome<iced::Rectangle> {
+            self.bounds.map_or(Outcome::None, Outcome::Some)
+        }
+    }
+
+    GetBounds {
+        target,
+        bounds: None,
+    }
+}
+
+pub enum Error {
+    Positioner,
+    InvalidPosition,
+    ParentNotFound,
+    ToplevelNotFound,
+    CreateFailed,
+}
+
+pub struct SnowcapPopup {
+    pub surface: SnowcapSurface,
+    pub popup: Popup,
+
+    pub popup_id: PopupId,
+    pub parent_id: ParentId,
+    pub toplevel_id: ParentId,
+
+    pub initial_configure_received: bool,
+
+    positioner: XdgPositioner,
+
+    pub wl_output: Option<WlOutput>,
+    output_size: iced::Size<u32>,
+    pending_output_size: Option<iced::Size<u32>>,
+
+    reposition_token: u32,
+    pending_reposition: Option<u32>,
+
+    recompute_size: bool,
+    current_size: iced::Size<u32>,
+    pending_size: Option<iced::Size<u32>>,
+
+    pub keyboard_key_sender: Option<UnboundedSender<KeyboardKey>>,
+}
+
+impl SnowcapPopup {
+    pub fn new(
+        state: &mut State,
+        parent_id: ParentId,
+        position: Position,
+        anchor: Option<xdg_positioner::Anchor>,
+        gravity: Option<xdg_positioner::Gravity>,
+        offset: Option<Offset>,
+        constraints_adjustment: Option<ConstraintAdjustment>,
+        grab_keyboard: bool,
+        widgets: ViewFn,
+    ) -> Result<Self, Error> {
+        let mut surface = SnowcapSurface::new(state, widgets, false);
+
+        let Ok(positioner) = XdgPositioner::new(&state.xdg_shell) else {
+            return Err(Error::Positioner);
+        };
+
+        if let Some(anchor) = anchor {
+            positioner.set_anchor(anchor);
+        }
+
+        if let Some(gravity) = gravity {
+            positioner.set_gravity(gravity);
+        }
+
+        if let Some(Offset { x, y }) = offset {
+            positioner.set_offset(x, y);
+        }
+
+        if let Some(adjustment) = constraints_adjustment {
+            positioner.set_constraint_adjustment(adjustment);
+        }
+        positioner.set_size(1, 1);
+        positioner.set_reactive();
+
+        let (popup, toplevel_id, focus_serial) = match parent_id {
+            ParentId::Popup(id) => {
+                let p = state
+                    .popups
+                    .iter_mut()
+                    .find(|p| p.popup_id == id)
+                    .ok_or(Error::ParentNotFound)?;
+
+                let iced::Rectangle {
+                    x,
+                    y,
+                    width,
+                    height,
+                } = position
+                    .anchor_rect_for(&mut p.surface)
+                    .ok_or(Error::InvalidPosition)?;
+
+                positioner.set_anchor_rect(x, y, width, height);
+
+                let Ok(popup) = Popup::from_surface(
+                    Some(p.popup.xdg_surface()),
+                    &positioner,
+                    &state.queue_handle,
+                    surface.wl_surface.clone(),
+                    &state.xdg_shell,
+                ) else {
+                    return Err(Error::CreateFailed);
+                };
+
+                (popup, p.toplevel_id, p.surface.focus_serial)
+            }
+            ParentId::Layer(id) => {
+                let l = state
+                    .layers
+                    .iter_mut()
+                    .find(|l| l.layer_id == id)
+                    .ok_or(Error::ParentNotFound)?;
+
+                let iced::Rectangle {
+                    x,
+                    y,
+                    width,
+                    height,
+                } = position
+                    .anchor_rect_for(&mut l.surface)
+                    .ok_or(Error::InvalidPosition)?;
+
+                positioner.set_anchor_rect(x, y, width, height);
+
+                let Ok(popup) = Popup::from_surface(
+                    None,
+                    &positioner,
+                    &state.queue_handle,
+                    surface.wl_surface.clone(),
+                    &state.xdg_shell,
+                ) else {
+                    return Err(Error::CreateFailed);
+                };
+
+                l.layer.get_popup(popup.xdg_popup());
+
+                (popup, parent_id, l.surface.focus_serial)
+            }
+            _ => unreachable!(),
+        };
+
+        if grab_keyboard {
+            if let Some(serial) = focus_serial
+                && let Some(seat) = state.seat.as_ref()
+            {
+                popup.xdg_popup().grab(seat, serial);
+            } else {
+                tracing::error!(
+                    "Could not grab keyboard for popup with parent {:?}",
+                    parent_id
+                );
+            }
+        }
+        popup.wl_surface().commit();
+
+        match toplevel_id {
+            ParentId::Layer(id) => {
+                let layer = state
+                    .layers
+                    .iter()
+                    .find(|l| l.layer_id == id)
+                    .ok_or(Error::ToplevelNotFound)?;
+                surface.toplevel_wl_surface = Some(layer.surface.wl_surface.clone());
+
+                // Popup don't receive frames unless the toplevel does.
+                layer.surface.request_frame();
+            }
+            _ => unreachable!(),
+        };
+
+        let next_id = state.popup_id_counter.next();
+
+        Ok(Self {
+            surface,
+            popup,
+            popup_id: next_id,
+            parent_id,
+            toplevel_id,
+            initial_configure_received: false,
+
+            positioner,
+            wl_output: None,
+            output_size: iced::Size {
+                width: 1,
+                height: 1,
+            },
+            pending_output_size: None,
+
+            reposition_token: 0,
+            pending_reposition: None,
+
+            recompute_size: false,
+            current_size: iced::Size {
+                width: 1,
+                height: 1,
+            },
+            pending_size: None,
+
+            keyboard_key_sender: None,
+        })
+    }
+
+    fn send_reposition(&mut self) {
+        let token = self.reposition_token;
+        self.reposition_token += 1;
+        self.pending_reposition = Some(token);
+        self.popup.reposition(&self.positioner, token);
+    }
+
+    pub fn request_view(&mut self) {
+        self.surface.request_view();
+    }
+
+    pub fn schedule_redraw(&mut self) {
+        self.surface.schedule_redraw();
+    }
+
+    pub fn update_properties(
+        &mut self,
+        anchor_rect: Option<iced::Rectangle<i32>>,
+        anchor: Option<xdg_positioner::Anchor>,
+        gravity: Option<xdg_positioner::Gravity>,
+        offset: Option<Offset>,
+        constraints_adjustment: Option<ConstraintAdjustment>,
+        widgets: Option<ViewFn>,
+    ) {
+        let mut update_pos = false;
+
+        if let Some(iced::Rectangle {
+            x,
+            y,
+            width,
+            height,
+        }) = anchor_rect
+        {
+            self.positioner.set_anchor_rect(x, y, width, height);
+            update_pos = true;
+        }
+
+        if let Some(anchor) = anchor {
+            self.positioner.set_anchor(anchor);
+            update_pos = true;
+        }
+
+        if let Some(gravity) = gravity {
+            self.positioner.set_gravity(gravity);
+            update_pos = true;
+        }
+
+        if let Some(Offset { x, y }) = offset {
+            self.positioner.set_offset(x, y);
+            update_pos = true;
+        }
+
+        if let Some(adjustment) = constraints_adjustment {
+            self.positioner.set_constraint_adjustment(adjustment);
+            update_pos = true;
+        }
+
+        if let Some(widgets) = widgets {
+            self.surface.view_changed(widgets);
+        }
+
+        if update_pos {
+            self.send_reposition();
+        }
+
+        self.recompute_size = true;
+        self.surface.request_frame();
+    }
+
+    pub fn draw_if_scheduled(&mut self) {
+        if self.pending_reposition.is_none() {
+            self.surface.draw_if_scheduled();
+        }
+    }
+
+    pub fn operate(&mut self, operation: &mut dyn widget::Operation) {
+        self.surface.operate(operation);
+    }
+
+    pub fn update(
+        &mut self,
+        runtime: &mut crate::runtime::Runtime,
+        compositor: &mut crate::compositor::Compositor,
+    ) {
+        if let Some(pending_size) = self.pending_size.take() {
+            self.current_size = pending_size;
+        }
+
+        if let Some(pending_output_size) = self.pending_output_size.take() {
+            self.output_size = pending_output_size;
+        }
+
+        self.surface.bounds_changed(self.widget_bounds());
+
+        let resized = self.surface.update(runtime, compositor);
+
+        if resized {
+            let iced::Size { width, height } = self.surface.widgets.size();
+            self.current_size = iced::Size::new(width, height);
+
+            // INFO: Our size may have increased. Let's inform the server.
+            if self.recompute_size {
+                self.positioner.set_size(width as i32, height as i32);
+
+                self.send_reposition();
+            }
+        }
+
+        self.recompute_size = false;
+    }
+
+    pub fn widget_bounds(&self) -> iced::Size<u32> {
+        if self.recompute_size {
+            self.output_size
+        } else {
+            self.current_size
+        }
+    }
+
+    pub fn size_changed(&mut self, new_size: iced::Size<u32>) {
+        self.pending_size = Some(new_size);
+    }
+
+    pub fn output_size_changed(&mut self, new_size: iced::Size<u32>) {
+        self.pending_output_size = Some(new_size);
+        self.recompute_size = true;
+    }
+
+    pub fn repositioned(&mut self, token: Option<u32>) {
+        if self.pending_reposition == token {
+            self.pending_reposition = None;
+            self.schedule_redraw();
+        }
+    }
+}
diff --git a/snowcap/src/server.rs b/snowcap/src/server.rs
index fbbcb6030..71971572f 100644
--- a/snowcap/src/server.rs
+++ b/snowcap/src/server.rs
@@ -2,14 +2,14 @@ use std::path::{Path, PathBuf};
 
 use anyhow::Context;
 use smithay_client_toolkit::reexports::calloop;
-use snowcap_api_defs::snowcap::{decoration, input, layer, widget};
+use snowcap_api_defs::snowcap::{decoration, input, layer, popup, widget};
 use tokio::task::JoinHandle;
 use tracing::{error, info};
 
 use crate::{
     api::{
         decoration::DecorationService, input::InputService, layer::LayerService,
-        widget::WidgetService,
+        popup::PopupService, widget::WidgetService,
     },
     state::State,
 };
@@ -64,6 +64,7 @@ impl State {
         let input_service = InputService::new(grpc_sender.clone());
         let widget_service = WidgetService::new(grpc_sender.clone());
         let decoration_service = DecorationService::new(grpc_sender.clone());
+        let popup_service = PopupService::new(grpc_sender.clone());
 
         let refl_service = tonic_reflection::server::Builder::configure()
             .register_encoded_file_descriptor_set(snowcap_api_defs::FILE_DESCRIPTOR_SET)
@@ -97,7 +98,10 @@ impl State {
                 decoration::v1::decoration_service_server::DecorationServiceServer::new(
                     decoration_service,
                 ),
-            );
+            )
+            .add_service(popup::v1::popup_service_server::PopupServiceServer::new(
+                popup_service,
+            ));
 
         let join_handle = tokio::spawn(async move {
             if let Err(err) = grpc_server.serve_with_incoming(uds_stream).await {
diff --git a/snowcap/src/state.rs b/snowcap/src/state.rs
index 35897976b..54391fdaa 100644
--- a/snowcap/src/state.rs
+++ b/snowcap/src/state.rs
@@ -10,7 +10,10 @@ use smithay_client_toolkit::{
         client::{
             Connection, QueueHandle,
             globals::registry_queue_init,
-            protocol::{wl_keyboard::WlKeyboard, wl_pointer::WlPointer},
+            protocol::{
+                wl_keyboard::WlKeyboard, wl_pointer::WlPointer, wl_seat::WlSeat,
+                wl_surface::WlSurface,
+            },
         },
         protocols::{
             ext::foreign_toplevel_list::v1::client::{
@@ -25,7 +28,7 @@ use smithay_client_toolkit::{
     },
     registry::RegistryState,
     seat::{SeatState, keyboard::Modifiers},
-    shell::wlr_layer::LayerShell,
+    shell::{WaylandSurface, wlr_layer::LayerShell, xdg::XdgShell},
 };
 use snowcap_protocols::snowcap_decoration_v1::client::snowcap_decoration_manager_v1::SnowcapDecorationManagerV1;
 use xkbcommon::xkb::Keysym;
@@ -34,9 +37,10 @@ use crate::{
     decoration::{DecorationIdCounter, SnowcapDecoration},
     handlers::{foreign_toplevel_list::ForeignToplevelListHandleData, keyboard::KeyboardFocus},
     layer::{LayerIdCounter, SnowcapLayer},
+    popup::{PopupIdCounter, SnowcapPopup},
     runtime::{CalloopSenderSink, CurrentTokioExecutor},
     server::GrpcServerState,
-    surface::CalloopNotifier,
+    surface::{self, CalloopNotifier},
     widget::SnowcapMessage,
 };
 
@@ -57,6 +61,7 @@ pub struct State {
     pub viewporter: WpViewporter,
     pub snowcap_decoration_manager: SnowcapDecorationManagerV1,
     pub foreign_toplevel_list: ExtForeignToplevelListV1,
+    pub xdg_shell: XdgShell,
 
     pub grpc_server_state: Option<GrpcServerState>,
 
@@ -67,16 +72,19 @@ pub struct State {
 
     pub layers: Vec<SnowcapLayer>,
     pub decorations: Vec<SnowcapDecoration>,
+    pub popups: Vec<SnowcapPopup>,
 
+    pub seat: Option<WlSeat>,
     // TODO: per wl_keyboard
     pub keyboard_focus: Option<KeyboardFocus>,
     pub keyboard_modifiers: Modifiers,
     pub keyboard: Option<WlKeyboard>, // TODO: multiple
 
     pub pointer: Option<WlPointer>, // TODO: multiple
-
+    // TODO: Do we need a pointer seat as well ?
     pub layer_id_counter: LayerIdCounter,
     pub decoration_id_counter: DecorationIdCounter,
+    pub popup_id_counter: PopupIdCounter,
 
     pub foreign_toplevel_list_handles:
         Vec<(ExtForeignToplevelHandleV1, ForeignToplevelListHandleData)>,
@@ -107,6 +115,8 @@ impl State {
         let foreign_toplevel_list: ExtForeignToplevelListV1 =
             globals.bind(&queue_handle, 1..=1, ()).unwrap();
 
+        let xdg_shell = XdgShell::bind(&globals, &queue_handle).unwrap();
+
         let wayland_source = WaylandSource::new(conn.clone(), event_queue);
 
         let dispatcher = Dispatcher::new(wayland_source, |_, queue, data| {
@@ -127,6 +137,9 @@ impl State {
                 for deco in state.decorations.iter_mut() {
                     deco.schedule_redraw();
                 }
+                for popup in state.popups.iter_mut() {
+                    popup.schedule_redraw();
+                }
             })
             .unwrap();
 
@@ -138,6 +151,9 @@ impl State {
                 for deco in state.decorations.iter_mut() {
                     deco.surface.invalidate_layout();
                 }
+                for popup in state.popups.iter_mut() {
+                    popup.surface.invalidate_layout();
+                }
             })
             .unwrap();
 
@@ -155,19 +171,25 @@ impl State {
         loop_handle
             .insert_source(recv, move |event, _, state| match event {
                 calloop::channel::Event::Msg((id, msg)) => {
-                    let Some(layer) = state
+                    let layer = state
                         .layers
                         .iter()
-                        .find(|layer| layer.surface.window_id == id)
-                    else {
-                        return;
-                    };
+                        .find(|layer| layer.surface.window_id == id);
+
+                    let popup = state
+                        .popups
+                        .iter()
+                        .find(|popup| popup.surface.window_id == id);
 
                     match msg {
                         SnowcapMessage::Noop => (),
                         SnowcapMessage::Close => (),
                         SnowcapMessage::KeyboardKey(key) => {
-                            if let Some(sender) = layer.keyboard_key_sender.as_ref() {
+                            let sender = layer
+                                .map(|l| l.keyboard_key_sender.as_ref())
+                                .or(popup.map(|p| p.keyboard_key_sender.as_ref()));
+
+                            if let Some(Some(sender)) = sender {
                                 let _ = sender.send(key);
                             }
                         }
@@ -230,6 +252,8 @@ impl State {
             }),
         ));
 
+        let seat = seat_state.seats().next();
+
         let state = State {
             loop_handle,
             loop_signal,
@@ -247,6 +271,7 @@ impl State {
             viewporter,
             snowcap_decoration_manager,
             foreign_toplevel_list,
+            xdg_shell,
 
             grpc_server_state: None,
             queue_handle,
@@ -254,15 +279,70 @@ impl State {
             tiny_skia: None,
             layers: Vec::new(),
             decorations: Vec::new(),
+            popups: Vec::new(),
+            seat,
             keyboard_focus: None,
             keyboard_modifiers: smithay_client_toolkit::seat::keyboard::Modifiers::default(),
             keyboard: None,
             pointer: None,
             layer_id_counter: LayerIdCounter::default(),
             decoration_id_counter: DecorationIdCounter::default(),
+            popup_id_counter: PopupIdCounter::default(),
             foreign_toplevel_list_handles: Vec::new(),
         };
 
         Ok(state)
     }
+
+    pub(crate) fn find_surface_mut(
+        &mut self,
+        wl_surface: &WlSurface,
+    ) -> Option<&mut surface::SnowcapSurface> {
+        if let Some(surface) = self
+            .layers
+            .iter_mut()
+            .filter_map(|l| {
+                if l.layer.wl_surface() == wl_surface {
+                    Some(&mut l.surface)
+                } else {
+                    None
+                }
+            })
+            .next()
+        {
+            return Some(surface);
+        }
+
+        if let Some(surface) = self
+            .decorations
+            .iter_mut()
+            .filter_map(|d| {
+                if &d.surface.wl_surface == wl_surface {
+                    Some(&mut d.surface)
+                } else {
+                    None
+                }
+            })
+            .next()
+        {
+            return Some(surface);
+        }
+
+        if let Some(surface) = self
+            .popups
+            .iter_mut()
+            .filter_map(|p| {
+                if &p.surface.wl_surface == wl_surface {
+                    Some(&mut p.surface)
+                } else {
+                    None
+                }
+            })
+            .next()
+        {
+            return Some(surface);
+        }
+
+        None
+    }
 }
diff --git a/snowcap/src/surface.rs b/snowcap/src/surface.rs
index a6eef626d..ceff6bd32 100644
--- a/snowcap/src/surface.rs
+++ b/snowcap/src/surface.rs
@@ -31,6 +31,7 @@ use crate::{
 pub struct SnowcapSurface {
     // This is an option so we can drop it first
     surface: Option<<crate::compositor::Compositor as iced_graphics::Compositor>::Surface>,
+    pub toplevel_wl_surface: Option<WlSurface>,
     pub wl_surface: WlSurface,
     compositor_state: CompositorState,
     queue_handle: QueueHandle<State>,
@@ -54,6 +55,7 @@ pub struct SnowcapSurface {
     clipboard: WaylandClipboard,
 
     pub pointer_location: Option<(f64, f64)>,
+    pub focus_serial: Option<u32>,
 
     pub window_id: iced::window::Id,
 
@@ -67,6 +69,8 @@ impl Drop for SnowcapSurface {
     fn drop(&mut self) {
         // SAFETY: This needs to be dropped first, it implicitly borrows the wl_surface
         self.surface.take();
+        // SAFETY: If a toplevel surface was set, let's drop it early.
+        self.toplevel_wl_surface.take();
 
         self.fractional_scale.destroy();
         self.wl_surface.destroy();
@@ -123,6 +127,7 @@ impl SnowcapSurface {
 
         Self {
             surface: Some(iced_surface),
+            toplevel_wl_surface: None,
             wl_surface,
             compositor_state,
             queue_handle: state.queue_handle.clone(),
@@ -139,6 +144,7 @@ impl SnowcapSurface {
             renderer,
             clipboard,
             pointer_location: None,
+            focus_serial: None,
             viewport,
             fractional_scale,
             window_id: iced::window::Id::unique(),
@@ -384,6 +390,11 @@ impl SnowcapSurface {
         self.wl_surface
             .frame(&self.queue_handle, self.wl_surface.clone());
         self.wl_surface.commit();
+
+        if let Some(wl_surface) = self.toplevel_wl_surface.as_ref() {
+            wl_surface.frame(&self.queue_handle, wl_surface.clone());
+            wl_surface.commit();
+        }
     }
 }
 
diff --git a/src/handlers.rs b/src/handlers.rs
index 1e382a7c2..5d681488e 100644
--- a/src/handlers.rs
+++ b/src/handlers.rs
@@ -44,12 +44,9 @@ use smithay::{
         pointer::{self, CursorImageStatus, PointerHandle},
     },
     output::{Mode, Output, Scale},
-    reexports::{
-        wayland_protocols::xdg::shell::server::xdg_positioner::ConstraintAdjustment,
-        wayland_server::{
-            Client, Resource,
-            protocol::{wl_buffer::WlBuffer, wl_output::WlOutput, wl_surface::WlSurface},
-        },
+    reexports::wayland_server::{
+        Client, Resource,
+        protocol::{wl_buffer::WlBuffer, wl_output::WlOutput, wl_surface::WlSurface},
     },
     utils::{Logical, Point, Rectangle},
     wayland::{
@@ -1050,13 +1047,6 @@ impl Pinnacle {
             .map(|win| win.total_decoration_offset())
             .unwrap_or_default();
 
-        if parent == root {
-            // Slide toplevel popup x's instead of flipping; this mimics Awesome
-            positioner
-                .constraint_adjustment
-                .remove(ConstraintAdjustment::FlipX);
-        }
-
         // The anchor rectangle is relative to the window's wl surface.
         // If there is a decoration, we need to offset the anchor rect
         // by the decoration offset.
diff --git a/src/handlers/xdg_shell.rs b/src/handlers/xdg_shell.rs
index 98b161f86..1083b2dac 100644
--- a/src/handlers/xdg_shell.rs
+++ b/src/handlers/xdg_shell.rs
@@ -174,9 +174,6 @@ impl XdgShellHandler for State {
             debug!("Failed to reposition popup: {err}");
         }
         surface.send_repositioned(token);
-        if let Err(err) = surface.send_configure() {
-            warn!("Failed to configure popup: {err}");
-        }
     }
 
     fn grab(&mut self, surface: PopupSurface, seat: WlSeat, serial: Serial) {