Crate gpui

Expand description

§FC GPUI

A GPU-accelerated UI framework for Rust, forked from Zed’s GPUI. fc-gpui extends the original framework with daemon-mode capabilities, system tray integration, global hotkeys, native notifications, and more — making it suitable for background apps, menu bar utilities, and overlay tools.

§Getting Started

fc-gpui 0.11.3 is published on crates.io. The unrelated adabraka-gpui registry crate is the upstream Augani crate at 0.5.1 and does not carry this fork’s releases. Depend on the crates.io package:

fc-gpui = "0.11.3"

Building requires the toolchain pinned in rust-toolchain.toml: Rust 1.97.1 with edition 2024.

To keep the build small, disable default features and opt into only the image formats you need:

fc-gpui = { version = "0.11.3", default-features = false, features = [
    "font-kit",
    "wayland",
    "x11",
    "image-format-png",
    "image-format-jpeg",
    "image-format-webp",
] }

image-format-* features map to the underlying image crate decoder features. image-rayon re-enables parallel decoding. SVG support is handled separately through resvg.

Note that keyring (Linux Secret Service credentials storage) and accessibility are also default features; add "keyring" back to the list above if your app calls write_credentials / read_credentials / delete_credentials.

§Import Naming

The published package is fc-gpui, but the library target keeps the upstream gpui namespace, so a plain dependency imports as gpui and Zed-derived code compiles unchanged:

use gpui::*;

Renaming the dependency is also supported — the GPUI macros (derives, register_action!, #[gpui::test]) follow the dependency key:

[dependencies]
gpui = { package = "fc-gpui", version = "0.11.3" }

The utility crates (fc-gpui-util, fc-gpui-http-client, …) import under their matching fc_gpui_* library names.

§Macro Dependency Override

Macro paths are resolved automatically for normal fc-gpui dependencies and ordinary Cargo aliases. If one package directly lists both fc-gpui and fc-gpui-core, or uses an alias that is indistinguishable from the normalized package name, select the intended crate once in the consuming package’s Cargo.toml:

[package.metadata.gpui-macros]
crate = "core_ui"

The value must be the Rust dependency identifier visible to that package. It applies consistently to derive macros, register_action!, and #[gpui::test]. An ambiguous direct dependency graph without this override fails with an actionable macro error instead of guessing a crate.

§Platform Support

Feature	macOS	Linux (X11)	Linux (Wayland)	Windows
GPU-accelerated rendering	Metal	Vulkan/OpenGL	Vulkan/OpenGL	DirectX
System tray icon & menu	Yes	Yes (DBus/SNI)	Yes (DBus/SNI)	Yes (Shell_NotifyIcon)
Tray menu actions	Yes	Yes	Yes	Yes
Global hotkeys	Yes	Yes (XGrabKey)	No (protocol limitation)	Yes (RegisterHotKey)
Native notifications	Yes (UNUserNotification)	Yes (notify-rust)	Yes (notify-rust)	Yes (Shell balloon)
Overlay windows (always-on-top)	Yes	Yes	Yes (`WindowKind::LayerShell`)	Yes
Click-through windows	Yes	Yes (Shape ext)	Yes (wl_region)	Yes (WS_EX_TRANSPARENT)
Window show/hide	Yes	Yes	Yes	Yes
Auto-launch at login	Yes (SMAppService)	Yes (XDG autostart)	Yes (XDG autostart)	Yes (Registry)
Single instance lock	Yes (Unix socket)	Yes (Unix socket)	Yes (Unix socket)	Yes (Named mutex)
Focused window info	Yes (Accessibility)	Yes (EWMH)	No	Yes (Win32)
Permission queries	Yes (Accessibility, Mic)	No	No	No
Daemon mode (no dock icon)	Yes (Accessory policy)	Yes	Yes	Yes

§Rendering Backends

Linux X11 and Wayland use the internal wgpu renderer ported from Zed’s current GPUI backend. Blade is no longer part of the crate. The default macOS renderer is Metal and Windows uses DirectX.

Downstream applications continue to use only fc-gpui; the renderer package is an internal implementation dependency and does not change the Application::new() entry point. See the WGPU migration notes for details.

§Accessibility

fc-gpui exposes AccessKit-backed roles, labels, values, focus, and action handlers on elements. Native adapters connect the generated accessibility tree to macOS Accessibility, Linux AT-SPI, and Windows UI Automation.

Native adapters are enabled by the default accessibility feature. Disable default features to exclude their platform dependencies; the core accessibility API remains available but inactive.

cargo run -p fc-gpui --example a11y

See examples/a11y.rs for focus navigation, accessible actions, numeric values, switches, and list metadata.

§Wayland Layer Shell

Create a layer-shell surface with WindowKind::LayerShell. The Wayland backend requires wlr-layer-shell; opening the window fails with LayerShellNotSupportedError when the selected backend or compositor does not support that protocol. Compositors older than wlr-layer-shell version 5 cannot select exclusive_edge, so that option is ignored with a warning. A width or height of zero is passed through to let the compositor choose that dimension.

Applications upgrading from 0.6.x should follow the layer-shell migration and implementation provenance guide.

use gpui::{
    Bounds, WindowBounds, WindowKind, WindowOptions,
    layer_shell::{Anchor, KeyboardInteractivity, LayerShellOptions}, point, px, size,
};

let popup_bounds = Bounds::new(point(px(1520.0), px(820.0)), size(px(320.0), px(220.0)));

let options = WindowOptions {
    window_bounds: Some(WindowBounds::Windowed(popup_bounds)),
    kind: WindowKind::LayerShell(LayerShellOptions {
        namespace: "gpui-popup".to_string(),
        anchor: Anchor::TOP | Anchor::RIGHT,
        margin: Some((px(24.0), px(24.0), px(0.0), px(0.0))),
        keyboard_interactivity: KeyboardInteractivity::None,
        ..Default::default()
    }),
    ..WindowOptions::default()
};

The layer-shell regression tests avoid requiring a real compositor. They cover configure sizing and protocol enum mapping:

cargo test -p fc-gpui-core --lib --features test-support layer_shell
cargo check -p fc-gpui --example layer_shell --features wayland

§Features

§Core UI Framework (inherited from GPUI)

Hybrid immediate/retained mode rendering
GPU-accelerated with Metal, Vulkan, OpenGL, and DirectX backends
Tailwind-style layout and styling API
Entity-based state management
Declarative views with the Render trait
Low-level Element API for custom rendering
Async executor integrated with the platform event loop
Action system for keyboard shortcuts
AccessKit accessibility tree and native platform adapters
Test framework with #[gpui::test]

§Daemon & Background App Support (new in fc-gpui)

System tray — icon, tooltip, and nested menus with action callbacks
Global hotkeys — register system-wide keyboard shortcuts
Native notifications — OS-level notifications on all platforms
Overlay windows — always-on-top transparent windows
Click-through windows — mouse events pass through to windows below
Window show/hide — programmatic visibility control
Auto-launch — register your app to start at login
Single instance — prevent multiple copies with activation signaling
Keep alive without windows — apps stay alive with no visible windows via QuitMode::Explicit, set through Application::with_quit_mode or App::set_quit_mode
Focused window info — query which window the user is focused on
Permission status — check accessibility and microphone permissions
In-app toast notifications — stackable, auto-dismissing toast component (deprecated; use the fc-ui toast component instead)

§Quick Example

use gpui::{App, Application, TrayMenuItem};

fn main() {
    Application::new().run(|cx: &mut App| {
        cx.set_quit_mode(gpui::QuitMode::Explicit);
        cx.set_tray_tooltip("My App");

        cx.set_tray_menu(vec![
            TrayMenuItem::Action {
                label: "Settings".into(),
                id: "settings".into(),
            },
            TrayMenuItem::Separator,
            TrayMenuItem::Action {
                label: "Quit".into(),
                id: "quit".into(),
            },
        ]);

        cx.on_tray_menu_action(|id, cx| match id.as_ref() {
            "quit" => cx.quit(),
            _ => {}
        });
    });
}

§Dependencies

§macOS

Xcode with macOS components
Xcode command line tools: xcode-select --install

§Linux

Standard development packages for your distro
For X11: libxcb, libxkbcommon
For Wayland: libwayland-client, libxkbcommon
GPU backend: wgpu with Vulkan/OpenGL support
D-Bus (for system tray via StatusNotifierItem)

§Windows

Visual Studio Build Tools with C++ workload
Windows SDK

§License

Apache-2.0

Modules§

accesskit
colors: The default colors used by GPUI.
http_client
inspector_reflection: Provides definitions used by #[derive_inspector_reflection].
layer_shell: Wayland layer-shell window configuration.
prelude: The GPUI prelude is a collection of traits and types that are widely used throughout the library. It is recommended to import this prelude into your application to avoid having to import each trait individually.
single_instance: Cross-platform single instance enforcement using Unix domain sockets and Windows named mutexes.
styled_reflection: Implements function reflection
window_positioner: Pure Rust utility for computing window bounds from a semantic WindowPosition.

Macros§

actions: Defines and registers unit structs that can be used as actions. For more complex data types, derive Action.
register_action: This can be used to register an action with the GPUI runtime when you want to manually implement the Action trait. Typically you should use the Action derive macro or actions! macro instead.

Structs§

A11yCallbacks: Callbacks for the accessibility adapter.
ActivityGuard: Keeps an operating system activity, such as an idle sleep inhibitor, alive until dropped.
Anchored: An anchored element that can be used to display UI that will avoid overflowing the window bounds.
AnchoredState: The state that the anchored element element uses to track its children.
Animation: An animation that can be applied to an element.
AnimationElement: A GPUI element that applies an animation to another element
AnimationHandle: A handle that can be used to cancel an in-flight animation.
AnimationPhase: A potentially overshooting coordinate within an animation.
AnyDrag: Contains state associated with an active drag operation, started by dragging an element within the window or by dragging into the app from the underlying platform.
AnyElement: A dynamically typed element that can be used to store any element type.
AnyEntity: A dynamically typed reference to a entity, which can be downcast into a Entity<T>.
AnyImageCache: A dynamically typed image cache, which can be used to store any image cache
AnyTooltip: Contains state associated with a tooltip. You’ll only need this struct if you’re implementing tooltip behavior on a custom element. Otherwise, use Div::tooltip.
AnyView: A dynamically-typed handle to a view, which can be downcast to a Entity for a specific type.
AnyWeakEntity: A type erased, weak reference to a entity.
AnyWeakView: A weak, dynamically-typed view handle that does not prevent the view from being released.
AnyWindowHandle: A handle to a window with any root view type, which can be downcast to a window with a specific root view type.
App: Contains the state of the full application, and passed as a reference to a variety of callbacks. Other Context derefs to this type. You need a reference to an App to access the state of a Entity.
AppResourceProfile: Fine-grained resource budget for a GPUI application.
Application: Configures and launches a GPUI application.
ApplicationHandle: A strong handle to an Application started with Application::run_embedded.
ArenaClearNeeded: Returned when the element arena has been used and so must be cleared before the next draw.
AsyncApp: An async-friendly version of App with a static lifetime so it can be held across await points in async code. You’re provided with an instance when calling App::spawn, and you can also create one with App::to_async. Internally, this holds a weak reference to an App, so its methods are fallible to protect against cases where the App is dropped.
AsyncWindowContext: A cloneable, owned handle to the application context, composed with the window associated with the current task.
AtlasTextureId
AtlasTile
Background: A background color, which can be a solid color, linear gradient, radial gradient, or conic gradient.
BackgroundExecutor: A pointer to the executor that is currently running, for spawning background tasks.
BindingIndex: Index of a binding within a keymap.
Boundary: A boundary between two lines of text.
Bounds: Represents a rectangular area in a 2D space with an origin point and a size.
BoundsRefinement: A refinable version of [#ident], see that documentation for details.
BoxShadow: The possible values of the box-shadow property
Canvas: A canvas element, meant for accessing the low level paint API without defining a whole custom element
Capslock: The state of the capslock key at some point in time
Cascade: A cascade of refinements that can be merged in priority order.
CascadeSlot: A handle to a specific slot in a cascade.
ClipboardItem: A clipboard item that should be copied to the clipboard
ClipboardString: A clipboard item that should be copied to the clipboard
ContainerQuery: A container query element, created with container_query.
ContentMask: Indicates which region of the window is visible. Content falling outside of this mask will not be rendered. Currently, only rectangular content masks are supported, but we give the mask its own type to leave room to support more complex shapes in the future.
Context: The app context, with specialized behavior for the given entity.
ContextEntry: An entry in a KeyContext
Corners: Represents the corners of a box in a 2D space, such as border radius.
CornersRefinement: A refinable version of [#ident], see that documentation for details.
CrashReport: Information collected for a crash report.
DebugBelow: Use this struct for interfacing with the ‘debug_below’ styling from your own elements. If a parent element has this style set on it, then this struct will be set as a global in GPUI.
DecorationRun: Set the text decoration for a run of text.
Deferred: An element which delays the painting of its child until after all of its ancestors, while keeping its layout as part of the current element tree.
DeferredScrollToItem
DevicePixels: Represents physical pixels on the display.
DialogOptions: Options for displaying a native dialog.
DismissEvent: Emitted by implementers of ManagedView to indicate the view should be dismissed, such as when a view is presented as a modal.
DispatchEventResult
DisplayId: An opaque identifier for a hardware display
Div: A Div element, the all-in-one element for building complex UIs in GPUI
DivFrameState: A frame state for a Div element, which contains layout IDs for its children.
DivInspectorState: Interactivity state displayed an manipulated in the inspector.
DragMoveEvent: An event for when a drag is moving over this element, with the given state type.
Drawable: A wrapper around an implementer of Element that allows it to be drawn in a window.
DummyKeyboardMapper: A dummy implementation of the platform keyboard mapper
Edges: Represents the edges of a box in a 2D space, such as padding or margin.
EdgesRefinement: A refinable version of [#ident], see that documentation for details.
ElementClickedState: Whether or not the element or a group that contains it is clicked by the mouse.
ElementInputHandler: The canonical implementation of PlatformInputHandler. Call Window::handle_input with an instance during your element’s paint.
Empty: The empty element, which renders nothing.
EmptyView: A view that renders nothing
Entity: A strong, well-typed reference to a struct which is managed by GPUI
EntityId: A unique identifier for a entity across the application.
ExternalPaths: A collection of paths from the platform, such as from a file drop.
FallbackPromptRenderer: The default GPUI fallback for rendering prompts, when the platform doesn’t support it.
FillOptions: Parameters for the fill tessellator.
FocusHandle: A handle which can be used to track and manipulate the focused element in a window.
FocusId: A globally unique identifier for a focusable element.
FocusOutEvent: This is provided when subscribing for Context::on_focus_out events.
FocusedWindowInfo: Information about the currently focused window from any application.
Font: The configuration details for identifying a specific font.
FontFallbacks: The fallback fonts that can be configured for a given font. Fallback fonts family names are stored here.
FontFamilyId: An opaque identifier for a specific font family.
FontFeatures: The OpenType features that can be configured for a given font.
FontId: An opaque identifier for a specific font.
FontMetrics: A struct for storing font metrics. It is used to define the measurements of a typeface.
FontRun: A run of text with a single font.
FontWeight: The degree of blackness or stroke thickness of a font. This value ranges from 100.0 to 900.0, with 400.0 as normal.
ForegroundExecutor: A pointer to the executor that is currently running, for spawning tasks on the main thread.
GlobalElementId: A globally unique identifier for an element, used to track state across frames.
GlyphId: An identifier for a specific glyph, as returned by WindowTextSystem::layout_line.
GpuResourceBudget: GPU resource budget.
GpuSpecs: Information about the GPU GPUI is running on.
GpuiBorrow: A mutable reference to an entity owned by GPUI
GridLocation: A location in a grid layout.
GridTemplate: A simplified representation of a repeated grid-template-* value.
GridTemplateRefinement: A refinable version of [#ident], see that documentation for details.
GroupStyle: The styling information for a given group.
HighlightStyle: A highlight style to apply, similar to a TextStyle except for a single font, uniformly sized and spaced text.
Hitbox: A rectangular region that potentially blocks hitboxes inserted prior. See Window::insert_hitbox for more details.
HitboxId: An identifier for a Hitbox which also includes HitboxBehavior.
Hsla: An HSLA color
Image: An image, with a format and certain bytes
ImageCacheElement: An image cache element.
ImageCacheItem: Owns an image load and its cached result.
ImageFormatIter: An iterator over the variants of ImageFormat
ImageId: A unique identifier for the image cache
ImageStyle: The style of an image element.
Img: An image element.
ImgLayoutState: The image layout state between frames
Inspector: Manages inspector state - which element is currently selected and whether the inspector is in picking mode.
InspectorElementId: A unique identifier for an element that can be inspected.
InspectorElementPath: GlobalElementId qualified by source location of element construction.
InteractiveElementState: The per-frame state of an interactive element. Used for tracking stateful interactions like clicks and scroll offsets.
InteractiveText: A text element that can be interacted with.
Interactivity: The interactivity struct. Powers all of the general-purpose interactivity in the Div element.
InvalidKeystrokeError: Error type for Keystroke::parse. This is used instead of anyhow::Error so that Zed can use markdown to display it.
ItemSize: The size of the item and its contents.
KeyBinding: A keybinding and its associated metadata, from the keymap.
KeyBindingMetaIndex: A unique identifier for retrieval of metadata associated with a key binding. Intended to be used as an index or key into a user-defined store of metadata associated with the binding, such as the source of the binding.
KeyContext: A datastructure for resolving whether an action should be dispatched at this point in the element tree. Contains a set of identifiers and/or key value pairs representing the current context for the keymap.
KeyDownEvent: The key down event equivalent for the platform.
KeyUpEvent: The key up event equivalent for the platform.
KeybindingKeystroke: Represents a keystroke that can be used in keybindings and displayed to the user.
KeyboardClickEvent: A click event that was generated by a keyboard button being pressed and released.
Keymap: A collection of key bindings for the user’s application.
KeymapVersion: An opaque identifier of which version of the keymap is currently active. The keymap’s version is changed whenever bindings are added or removed.
Keystroke: A keystroke and associated metadata generated by the platform
KeystrokeEvent: A keystroke event, and potentially the associated action
LayoutId: A unique identifier for a layout node, generated when requesting a layout from Taffy
LineLayout: A laid out and styled line of text
LineWrapper: The GPUI line wrapper, used to wrap lines of text to a given width.
LineWrapperHandle: A handle into the text system, which can be used to compute the wrapped layout of text
LinearColorStop: A color stop in a linear gradient.
List: A list element
ListOffset: An offset into the list’s items, in terms of the item index and the number of pixels off the top left of the item.
ListPrepaintState: Frame state used by the List element after layout.
ListScrollEvent: A scroll event that has been converted to be in terms of the list’s items.
ListState: The list state that views must hold on behalf of the list element.
Menu: A menu of the application, either a main menu or a submenu
MissingGlyph: A grapheme cluster that could not be represented by any available font.
Modifiers: The state of the modifier keys at some point in time
ModifiersChangedEvent: The modifiers changed event equivalent for the platform.
MonochromeSprite
MouseClickEvent: A click event, generated when a mouse button is pressed and released.
MouseDownEvent: A mouse down event from the platform
MouseExitEvent: A mouse exit event from the platform, generated when the mouse leaves the window.
MouseMoveEvent: A mouse move event from the platform
MouseUpEvent: A mouse up event from the platform
NoAction: Action with special handling which unbinds the keybinding this is associated with, if it is the highest precedence match.
NoopTextSystem
OngoingScroll: Tracks the dominant axis across the events in a scroll gesture.
OsInfo: Information about the operating system.
OsMenu: OS menus are menus that are recognized by the operating system This allows the operating system to provide specialized items for these menus
OwnedMenu: A menu of the application, either a main menu or a submenu
OwnedOsMenu: OS menus are menus that are recognized by the operating system This allows the operating system to provide specialized items for these menus
PaddedBool32: A boolean stored as a u32 so GPU-facing structs contain no compiler-inserted padding bytes when reinterpreted as instance data.
PaintQuad: A rectangle to be rendered in the window at the given position and size. Passed as an argument Window::paint_quad.
PaintSurface
Path: A line made up of a series of vertices and control points.
PathBuilder: A Path builder.
PathPromptOptions: The options that can be configured for a file dialog prompt
PathVertex
PendingInputStatus: Pending input for a potential multi-stroke key binding.
PendingInputTimeoutStatus: The timeout state for pending input.
Percentage: A type representing a percentage value.
PinchEvent: A pinch gesture event from the platform, generated when the user performs a pinch-to-zoom gesture.
Pixels: Represents a length in pixels, the base unit of measurement in the UI framework.
PlatformInputHandler
Point: Describes a location in a 2D cartesian space.
PointRefinement: A refinable version of [#ident], see that documentation for details.
PolychromeSprite
PromptHandle: A handle to a prompt that can be used to interact with it.
PromptResponse: The event emitted when a prompt’s option is selected. The usize is the index of the selected option, from the actions passed to the prompt.
Quad
Radians: Represents an angle in Radians
Rems: Represents a length in rems, a unit based on the font-size of the window, which can be assigned with Window::set_rem_size.
RenderGlyphParams
RenderImage: A cached and processed image, in BGRA format
RenderImageParams
RenderablePromptHandle: A prompt handle capable of being rendered in a window.
RendererCacheStats: Snapshot of the renderer’s pooled GPU resource usage.
RequestFrameOptions
Reservation: Returned by Context::reserve_entity to later be passed to Context::insert_entity. Allows you to obtain the EntityId for a entity before it is created.
ResizeEvent: An event that fires when an element’s bounds change size.
RetainAllImageCache: An implementation of ImageCache, that uses an LRU caching strategy to unload images when the cache is full
RetainAllImageCacheProvider: A provider struct for creating a retain-all image cache inline
Rgba: An RGBA color
ScaledPixels: Represents scaled pixels that take into account the device’s scale factor.
Scene
Scope: Scope manages a set of tasks that are enqueued and waited on together. See BackgroundExecutor::scoped.
ScreenCaptureFrame: A frame of video captured from a screen.
ScrollAnchor: Represents an element that can be scrolled to in its parent element. Contrary to ScrollHandle::scroll_to_active_item, an anchored element does not have to be an immediate child of the parent.
ScrollHandle: A handle to the scrollable aspects of an element. Used for accessing scroll state, like the current scroll offset, and for mutating the scroll state, like scrolling to a specific child.
ScrollWheelEvent: A mouse wheel event from the platform
SemanticVersion: A semantic version number.
Shadow
ShapedGlyph: A single glyph, ready to paint.
ShapedLine: A line of text that has been shaped and decorated.
ShapedLineCursor: Incrementally splits a ShapedLine at increasing UTF-8 byte boundaries.
ShapedRun: A run of text that has been shaped .
SharedString: A shared string is an immutable string that can be cheaply cloned in GPUI tasks. Uses SmolStr for efficient storage with inline optimization for small strings.
SharedUri: A SharedString containing a URI.
Size: A structure representing a two-dimensional size with width and height in a given unit.
SizeRefinement: A refinable version of [#ident], see that documentation for details.
SourceMetadata: Metadata for a given ScreenCaptureSource
SpringAnimation: A stateful spring animation targeting a value or projected path.
SpringAnimationElement: A GPUI element driven by a stateful spring.
SpringConfig: The physical parameters of a damped harmonic oscillator.
SpringState: The instantaneous position and velocity of a spring.
Stateful: A wrapper around an element that can store state, produced after assigning an ElementId.
StrikethroughStyle: The properties that can be applied to a strikethrough.
StrikethroughStyleRefinement: A refinable version of [#ident], see that documentation for details.
StrokeOptions: Parameters for the tessellator.
Style: The CSS styling that can be applied to an element via the Styled trait
StyleRefinement: A refinable version of [#ident], see that documentation for details.
StyledText: Renders text with runs of different styles.
Subscription: A handle to a subscription created by GPUI. When dropped, the subscription is cancelled and the callback will no longer be invoked.
Surface: A surface element.
Svg: An SVG element.
SystemWindowTabController: A controller for managing window tabs.
Task: Task is a primitive that allows work to happen in the background.
TaskLabel: A task label is an opaque identifier that you can use to refer to a task in tests.
TextLayout: The Layout for TextElement. This can be used to map indices to pixels and vice versa.
TextResourceBudget: Text system resource budget.
TextRun: A styled run of text, for use in crate::TextLayout.
TextShadow: A shadow effect applied to text, rendered by painting glyphs twice.
TextStyle: The properties that can be used to style text in GPUI
TextStyleRefinement: A refinable version of [#ident], see that documentation for details.
TextSystem: The GPUI text rendering sub system.
TextSystemCacheStats: Snapshot of the long-lived text-system cache sizes returned by TextSystem::layout_cache_stats.
TileId
Tiling: A type to describe which sides of the window are currently tiled in some way
Timeout: Error returned by with_timeout when the timeout duration elapsed before the future resolved
Timer: A future or stream that emits timed events.
TitlebarOptions: The options that can be configured for a window’s titlebar
ToastDeprecated: Configuration for a single toast notification.
ToastStackDeprecated: A stack of toast notifications that manages display and auto-dismissal.
TooltipId: An identifier for a tooltip.
Transformation: A transformation to apply to an SVG element.
TransformationMatrix: A data type representing a 2 dimensional transformation that can be applied to an element.
TrayAnchor
TrayIconClickEvent: A tray icon click event with optional screen position information.
UTF16Selection: A struct representing a selection in a text buffer, in UTF16 characters. This is different from a range because the head may be before the tail.
Underline
UnderlineStyle: The properties that can be applied to an underline.
UnderlineStyleRefinement: A refinable version of [#ident], see that documentation for details.
UniformList: A list element for efficiently laying out and displaying a list of uniform-height elements.
UniformListFrameState: Frame state used by the UniformList.
UniformListScrollHandle: A handle for controlling the scroll position of a uniform list. This should be stored in your view and passed to the uniform_list on each frame.
UniformListScrollState
WeakEntity: A weak reference to a entity of the given type.
WeakFocusHandle: A weak reference to a focus handle.
Window: Holds the state for a specific window.
WindowControls: What window controls this platform supports
WindowHandle: A handle to a window with a specific root view type. Note that this does not keep the window alive on its own.
WindowId: A unique identifier for a window.
WindowOptions: The variables that can be configured when creating a new window
WindowParams: The variables that can be configured when creating a new window
WindowState: A snapshot of a window’s state for save/restore.
WindowTextSystem: The GPUI text layout subsystem.
WrapBoundary: A boundary at which a line was wrapped
WrappedLine: A line of text that has been shaped, decorated, and wrapped by the text layout system.
WrappedLineLayout: A line of text that has been wrapped to fit a given width

Enums§

AbsoluteLength: Represents an absolute length in pixels or rems.
AccessibleAction: An action to be taken on an accessibility node.
ActionBuildError: Error type for Keystroke::parse. This is used instead of anyhow::Error so that Zed can use markdown to display it.
AlignContent: Sets the distribution of space between and around content items For Flexbox it controls alignment in the cross axis For Grid it controls alignment in the block axis
AlignItems: Used to control how child nodes are aligned. For Flexbox it controls alignment in the cross axis For Grid it controls alignment in the block axis
AnchoredFitMode: Which algorithm to use when fitting the anchored element to be inside the window.
AnchoredPositionMode: Which algorithm to use when positioning the anchored element.
AnimationRepeat: How an Animation behaves once one pass finishes.
AppProfile: Predefined application profiles for common use cases.
ArcCow
AssetLogger: An asset Loader which logs the Err variant of a Result during loading
AtlasKey
AtlasTextureKind
AttentionType: The type of user attention to request from the OS.
AvailableSpace: The space available for an element to be laid out in
Axis: Axis in a 2D cartesian space.
BiometricKind: The kind of biometric authentication available.
BiometricStatus: The availability status of biometric authentication.
BlendMode: The blend mode to apply when rendering a quad.
BorderStyle: The style of a border.
ClickEvent: A click event, generated when a mouse button or keyboard button is pressed and released.
ClipboardEntry: Either a ClipboardString or a ClipboardImage
ColorSpace: A color space for color interpolation.
Corner: Identifies a corner of a 2d box.
CursorStyle: The style of the cursor (pointer)
Decorations: A type to describe how this window is currently configured
DefiniteLength: A non-auto length that can be defined in pixels, rems, or percent of parent.
DialogKind: The kind of a native dialog.
DispatchPhase: Represents the two different phases when dispatching events.
Display: Sets the layout used for the children of this node
ElementId: An identifier for an Element.
FallbackFontClass: The spacing behavior required of a fallback font.
FileDropEvent: A file drop event from the platform, generated when files are dragged and dropped onto the window.
Fill: The kinds of fill that can be applied to a shape.
FillRule: The fill rule defines how to determine what is inside and what is outside of the shape.
FlexDirection: The direction of the flexbox layout main axis.
FlexWrap: Controls whether flex items are forced onto one line or can wrap onto multiple lines.
FollowMode: Controls whether the list automatically follows new content at the end.
FontStyle: Allows italic or oblique faces to be selected.
GridPlacement: The placement of an item within a grid layout’s column or row.
HitboxBehavior: How the hitbox affects mouse behavior.
HoverListenerMode: Controls how StatefulInteractiveElement::on_hover responds to key presses while the mouse is stationary.
ImageAssetLoader: An image loader for the GPUI asset system
ImageCacheError: An error that can occur when interacting with the image cache.
ImageFormat: One of the editor’s supported image formats (e.g. PNG, JPEG) - used when dealing with images in the clipboard
ImageSource: A source of image content.
IndentAdjustment: Controls how soft-wrapped continuation lines are indented.
InputPreference: Whether a keystroke should prefer character input or key bindings.
KeyBindingContextPredicate: A datastructure for resolving whether an action should be dispatched Representing a small language for describing which contexts correspond to which actions.
KeyboardButton: An enum representing the keyboard button that was pressed for a click event.
Length: A length that can be defined in pixels, rems, percent of parent, or auto.
LineFragment: A fragment of a line that can be wrapped.
ListAlignment: Whether the list is scrolling from top to bottom or bottom to top.
ListHorizontalSizingBehavior: The horizontal sizing behavior to apply during layout.
ListMeasuringBehavior: The measuring behavior to apply during layout.
ListSizingBehavior: The sizing behavior to apply during layout.
MediaKeyEvent: Media key events from hardware media keys or OS media controls.
MenuItem: The different kinds of items that can be in a menu
MouseButton: An enum representing the mouse button that was pressed.
NavigationDirection: A navigation direction, such as back or forward.
NetworkStatus: The current network connectivity status.
ObjectFit: How to fit the image into the bounds of the element.
Orientation
OsAction: OS actions are actions that are recognized by the operating system This allows the operating system to provide specialized behavior for these actions
Overflow: How children overflowing their container should affect layout
OwnedMenuItem: The different kinds of items that can be in a menu
PathStyle: Style of the PathBuilder
PermissionRequestStatus: Whether the platform accepted a permission request.
PermissionStatus: The status of a system permission.
PlatformInput: An enum corresponding to all kinds of platform input events.
Position: The positioning strategy for this item.
PowerSaveBlockerKind: The kind of power save blocker to create.
PrimitiveBatch
ProgressBarState: The state of a taskbar/dock progress bar for a window.
PromptButton: Prompt Button
PromptLevel: What kind of prompt styling to show
QuitMode: Defines when the application should automatically quit.
ResizeAnchor: The window corner or edge that stays fixed on screen when the window is resized via PlatformWindow::resize_anchored / crate::Window::resize_anchored.
ResizeEdge: Which part of the window to resize
Resource: An enum representing
Role: The type of an accessibility node.
ScreenCaptureStreamTermination: The terminal state of a started screen-capture stream.
ScrollDelta: The scroll delta for a scroll wheel event.
ScrollStrategy: Where to place the element scrolled to.
SpringPlayback: Controls how a spring advances and resolves its presentation value.
SurfaceSource: A source of a surface’s content.
SystemMenuType: The type of system menu
SystemPowerEvent: System power state change events.
TaskPriority: The scheduling priority for a task.
TemplateColumnMinSize: The minimum size of a repeated grid column or row.
TextAlign: How to align text within the element
TextOverflow: How to truncate text that overflows the width of the element
ThermalState: Thermal state of the system.
ToastPositionDeprecated: Position where toasts appear on screen.
Toggled
TouchPhase: The phase of a touch motion event. Based on the winit enum of the same name.
TrayIconEvent: Events that can occur on a system tray icon.
TrayIconRenderingMode: Controls how a system tray icon should be rendered.
TrayMenuItem: A menu item for a system tray context menu.
Visibility: The value of the visibility property, similar to the CSS property visibility
WhiteSpace: How to handle whitespace in text
WindowAppearance: The appearance of the window, as defined by the operating system.
WindowBackgroundAppearance: The appearance of the background of the window itself, when there is no content or the content is transparent.
WindowBounds: Represents the status of how a window should be opened.
WindowControlArea: A type of window control area that corresponds to the platform window.
WindowDecorations: A type to describe the appearance of a window
WindowKind: The kind of window to create
WindowPosition: A semantic window position for positioning windows relative to the screen.
WindowVisibility: Whether the platform is presenting a window’s frames.

Constants§

KEYSTROKE_PARSE_EXPECTED_MESSAGE: Sentence explaining what keystroke parser expects, starting with “Expected …”
LOADING_DELAY: The delay before showing the loading state.
SHUTDOWN_TIMEOUT: The duration for which futures returned from Context::on_app_quit can run before the application fully quits.
SUBPIXEL_VARIANTS_X: Number of subpixel glyph variants along the X axis.
SUBPIXEL_VARIANTS_Y: Number of subpixel glyph variants along the Y axis.

Traits§

Action: Actions are used to implement keyboard-driven UI. When you declare an action, you can bind keys to the action in the keymap and listeners for that action in the element tree.
Along: A trait for accessing the given unit along a certain axis.
AnimationExt: An extension trait for adding the animation wrapper to both Elements and Components
AppContext: The context trait, allows the different contexts in GPUI to be used interchangeably for certain operations.
AsKeystroke: This is a helper trait so that we can simplify the implementation of some functions
Asset: A trait for asynchronous asset loading.
AssetSource: A source of assets for this app to use.
BorrowAppContext: A helper trait for auto-implementing certain methods on contexts that can be used interchangeably.
Element: Implemented by types that participate in laying out and painting the contents of a window. Elements form a tree and are laid out according to web-based layout rules, as implemented by Taffy. You can create custom elements by implementing this trait, see the module-level documentation for more details.
EntityInputHandler: Implement this trait to allow views to handle textual input when implementing an editor, field, etc.
EventEmitter: A trait for tying together the types of a GPUI entity and the events it can emit.
Flatten: A flatten equivalent for anyhow Results.
Focusable: Focusable allows users of your view to easily focus it (using window.focus_view(cx, view))
FutureExt: Extensions for Future types that provide additional combinators and utilities.
GestureEvent: A gesture event from the platform.
Global: A marker trait for types that can be stored in GPUI’s global state.
Half: Provides a trait for types that can calculate half of their value.
ImageCache: An object that can handle the caching and unloading of images. Implementations of this trait should ensure that images are removed from all windows when they are no longer needed.
ImageCacheProvider: An object that can create an ImageCache during the render phase. See the ImageCache trait for more information.
InputEvent: An event from a platform input source.
InputHandler: Zed’s interface for handling text input from the platform’s IME system This is currently a 1:1 exposure of the NSTextInputClient API:
InteractiveElement: A trait for elements that want to use the standard GPUI event handlers that don’t require any state.
Interpolate: A value that supports linear interpolation and extrapolation.
IntoElement: Implemented by any type that can be converted into an element.
IsEmpty
IsZero: A trait for checking if a value is zero.
KeyEvent: A key event from the platform.
ManagedView: ManagedView is a view (like a Modal, Popover, Menu, etc.) where the lifecycle of the view is handled by another view.
MissingGlyphSink: Accepts missing glyphs detected by a platform text system.
MouseEvent: A mouse event from the platform.
Negate: Provides a trait for types that can negate their values.
ParentElement: This is a helper trait to provide a uniform interface for constructing elements that can accept any number of any kind of child elements
Platform: Low-level operating-system integration contract implemented by GPUI backends.
PlatformAtlas
PlatformDisplay: A handle to a platform’s display, e.g. a monitor or laptop screen.
PlatformKeyboardLayout: A trait for platform-specific keyboard layouts
PlatformKeyboardMapper: A trait for platform-specific keyboard mappings
PlatformTextSystem
PlatformWindow
Prompt: A prompt that can be rendered in the window.
ReadGlobal: A trait for reading a global value from the context.
Refineable: A trait for types that can be refined with partial updates.
Render: An object that can be drawn to the screen. This is the trait that distinguishes “views” from other entities. Views are Entity’s which impl Render and drawn to the screen.
RenderOnce: You can derive IntoElement on any type that implements this trait. It is used to construct reusable components out of plain data. Think of components as a recipe for a certain pattern of elements. RenderOnce allows you to invoke this pattern, without breaking the fluent builder pattern of the element APIs.
ScreenCaptureSource: A source of on-screen video content that can be captured.
ScreenCaptureStream: A video stream captured from a screen.
SpringTarget: A value that can be targeted by a one-dimensional spring.
StatefulInteractiveElement: A trait for elements that want to use the standard GPUI interactivity features that require state.
Styled: A trait for elements that can be styled. Use this to opt-in to a utility CSS-like styling API.
StyledImage: Style an image element.
UniformListDecoration: A decoration for a UniformList. This can be used for various things, such as rendering indent guides, or other visual effects.
UpdateGlobal: A trait for updating a global value in the context.
VisualContext: This trait is used for the different visual contexts in GPUI that require a window to be present.

Functions§

anchored: anchored gives you an element that will avoid overflowing the window bounds. Its children should have no margin to avoid measurement issues.
auto: Returns a Length representing an automatic length.
background_executor: Returns a background executor for the current platform.
black: Pure black in Hsla
blue: The color blue in Hsla
bounce: Apply the given easing function, first in the forward direction and then in the reverse direction
bounds: Create a bounds with the given origin and size
canvas: Construct a canvas element with the given paint callback. Useful for adding short term custom drawing to a view.
combine_highlights: Combine and merge the highlights and ranges in the two iterators.
conic_gradient: Creates a conic (sweep) gradient background.
container_query: Construct a container query element with the given render callback. The callback receives the size the element was assigned during layout and returns the contents to display within it.
current_platform: Returns the current desktop platform implementation.
deferred: Builds a Deferred element, which delays the layout and paint of its child.
div: Construct a new Div element
ease_in_out: The quadratic ease-in-out function, which starts and ends slowly but speeds up in the middle
ease_out_quint: The Quint ease-out function, which starts quickly and decelerates to a stop
fallback_prompt_renderer: Use this function in conjunction with App::set_prompt_builder to force GPUI to always use the fallback prompt renderer.
fill: Creates a filled quad with the given bounds and background color.
font: Get a Font for a given name.
generate_list_of_all_registered_actions: Generate a list of all the registered actions. Useful for transforming the list of available actions into a format suited for static analysis such as in validating keymaps, or generating documentation.
green: The color green in Hsla
guess_compositor: Returns which Linux compositor the environment indicates without connecting to it.
hash: Use a quick, non-cryptographically secure hash function to get an identifier from data
hsla: Construct an Hsla object from plain values
image_cache: An image cache element, all its child img elements will use the cache specified by this element. Note that this could as simple as passing an Entity<T: ImageCache>
img: Create a new image element.
is_no_action: Returns whether or not this action represents a removed key binding.
linear: The linear easing function, or delta itself
linear_color_stop: Creates a new linear color stop.
linear_gradient: Creates a LinearGradient background color.
list: Construct a new list element
multi_stop_linear_gradient: Creates a linear gradient with up to 4 color stops.
opaque_grey: Opaque grey in Hsla, values will be clamped to the range [0, 1]
outline: Creates a rectangle outline with the given bounds, border color, and a 1px border width
pattern_slash: Creates a hash pattern background
percentage: Generate a Radian from a percentage of a full circle.
phi: Returns the Golden Ratio, i.e. ~(1.0 + sqrt(5.0)) / 2.0.
point: Constructs a new Point<T> with the given x and y coordinates.
pulsating_between: A custom easing function for pulsating alpha that slows down as it approaches 0.1
px: Constructs a Pixels value representing a length in pixels.
quad: Creates a quad with the given parameters.
quadratic: The quadratic easing function, delta * delta
radial_gradient: Creates a radial gradient background.
radians: Create a Radian from a raw value
red: The color red in Hsla
relative: Constructs a DefiniteLength representing a relative fraction of a parent size.
rems: Constructs a Rems value representing a length in rems.
retain_all: Constructs a retain-all image cache that uses the element state associated with the given ID.
rgb: Convert an RGB hex color code number to a color type
rgba: Convert an RGBA hex color code number to Rgba
sampled_easing: Adapts a spring starting at zero with no velocity to GPUI’s duration-based easing API.
size: Constructs a new Size<T> with the provided width and height.
solid_background: Creates a solid background color.
surface: Create a new surface element.
svg: Create a new SVG element.
transparent_black: Transparent black in Hsla
transparent_white: Transparent white in Hsla
uniform_list: uniform_list provides lazy rendering for a set of items that are of uniform height. When rendered into a container with overflow-y: hidden and a fixed (or max) height, uniform_list will only render the visible subset of items.
white: Pure white in Hsla
yellow: The color yellow in Hsla

Type Aliases§

AlignSelf: Used to control how the specified nodes is aligned. Overrides the parent Node’s AlignItems property. For Flexbox it controls alignment in the cross axis For Grid it controls alignment in the block axis
DrawOrder
ImgResourceLoader: A type alias to the resource loader that the img() element uses.
InspectorRenderer: Function set on App to render the inspector UI.
JustifyContent: Sets the distribution of space between and around content items For Flexbox it controls alignment in the main axis For Grid it controls alignment in the inline axis
JustifyItems: Used to control how child nodes are aligned. Does not apply to Flexbox, and will be ignored if specified on a flex container For Grid it controls alignment in the inline axis
JustifySelf: Used to control how the specified nodes is aligned. Overrides the parent Node’s JustifyItems property. Does not apply to Flexbox, and will be ignored if specified on a flex child For Grid it controls alignment in the inline axis
PathVertex_ScaledPixels
Result: Result<T, Error>
ScreenCaptureTerminationCallback: Receives a single terminal state from a started screen-capture stream.
Transform: Alias for euclid::default::Transform2D<f32>

Attribute Macros§

test: #[gpui::test] can be used to annotate test functions that run with GPUI support.

Derive Macros§

Action: Action derive macro - see the trait documentation for details.
AppContext: #[derive(AppContext)] is used to create a context out of anything that holds a &mut App Note that a #[app] attribute is required to identify the variable holding the &mut App.
IntoElement: #[derive(IntoElement)] is used to create a Component out of anything that implements the RenderOnce trait.
Refineable
VisualContext: #[derive(VisualContext)] is used to create a visual context out of anything that holds a &mut Window and implements AppContext Note that a #[app] and a #[window] attribute are required to identify the variables holding the &mut App, and &mut Window respectively.

Crate gpui

Crate gpui Copy item path

§FC GPUI

§Getting Started

§Import Naming

§Macro Dependency Override

§Platform Support

§Rendering Backends

§Accessibility

§Wayland Layer Shell

§Features

§Core UI Framework (inherited from GPUI)

§Daemon & Background App Support (new in fc-gpui)

§Quick Example

§Dependencies

§macOS

§Linux

§Windows

§License

Modules§

Macros§

Structs§

Enums§

Constants§

Traits§

Functions§

Type Aliases§

Attribute Macros§

Derive Macros§

Crate gpui