Agent skill

Gpui Kit

by StudentWeis in StudentWeis/ropy

How to build desktop applications with GPUI Kit, the Rust framework published as the gpui-kit crate (GPUI plus gpuikit::component, gpuikit::base, gpuikit::assets).

MITAuto-check passedFrontend & Design

Install Gpui Kit

skills CLI
$ npx skills add StudentWeis/ropy --skill gpui-kit -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install StudentWeis/ropy gpui-kit --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/StudentWeis/ropy.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/gpui-kit .claude/skills/gpui-kit && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
gpui-kit
GitHub stars
195
Used in
1 other repo
Token cost
~5.6k tokens
SKILL.md length
1,436 words
Files
27 (incl. references)
Skills in repo
7
Repo updated
First seen
Licence
MIT

At a glance

How to build desktop applications with GPUI Kit, the Rust framework published as the gpui-kit crate (GPUI plus gpuikit::component, gpuikit::base, gpuikit::assets).

  • Setting up a gpui-kit app
  • SKILL.md covers Read the Guides First, Documentation, Quick Reference and Component Catalog, plus 2 more sections
  • Reaches gpui-kit.com
  • Using a component (Button

What it does

Gpui Kit is an agent skill from StudentWeis/ropy. How to build desktop applications with GPUI Kit, the Rust framework published as the gpui-kit crate (GPUI plus gpuikit::component, gpuikit::base, gpuikit::assets). Use when setting up a gpui-kit app, choosing or using a component (Button, Input, Select, Dialog, Sheet, Tabs, Sidebar, List, DataTable, Tree, Chart, etc.), handling component state, theming, or window overlays, and for GPUI mechanics: actions and keybindings, async tasks, contexts, custom elements, entities, events, focus, global state, layout and…

Its SKILL.md is about 5.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 28 other files, including reference files (for example `references/coding-guides.md`, `references/conventions.md` and `references/gpui/action.md`).

It sits in Frontend & Design, covering Theming and dark mode, State management and Integration testing. It works with Rust. The repository describes itself as: Cross-platform, lightweight clipboard manager written in Rust and GPUI. The licence is MIT.

When your agent uses it

  • Setting up a gpui-kit app
  • Using a component (Button
  • Handling component state
  • Window overlays

Example prompts

  • “/gpui-kit”

What it can do on your machine

Read from SKILL.md and the folder at commit 8ab193e. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are rust).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • gpui-kit.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Gpui Kit loads about 5.6k tokens when it runs, and up to ~78k if it reads all its reference files. Until then it costs about 196 tokens; SKILL.md has 1,436 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~196
When it runs · the whole SKILL.md, loaded when a task matches
~5.6k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~78k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from StudentWeis/ropy at commit 8ab193e, republished under its MIT licence (© StudentWeis). 1,436 words, ~5,622 tokens.

Download SKILL.mdSave it as .claude/skills/gpui-kit/SKILL.md (or your agent's skills folder). This skill also uses 26 other files; get the full folder from GitHub.
name
gpui-kit
description
How to build desktop applications with GPUI Kit, the Rust framework published as the gpui-kit crate (GPUI plus gpui_kit::component, gpui_kit::base, gpui_kit::assets). Use when setting up a gpui-kit app, choosing or using a component (Button, Input, Select, Dialog, Sheet, Tabs, Sidebar, List, DataTable, Tree, Chart, etc.), handling component state, theming, or window overlays, and for GPUI mechanics: actions and keybindings, async tasks, contexts, custom elements, entities, events, focus, global state, layout and styling, ElementId, and tests including UI integration testing. Holds the normative Coding Guides: read them before any architecture, state-ownership, public API, naming, or testing decision. Pairs with the gpui-kit-design-guides skill for the Design Guides.

GPUI Kit

Applications depend on one crate, gpui-kit. GPUI is use gpui_kit::*;, and each layer is reachable by name: gpui_kit::component (styled components), gpui_kit::base (unstyled behavior), gpui_kit::assets (default icons), gpui_kit::platform.

Start with component-family conventions to choose the constructor, state owner, event, and layout contract for the task. Learn the family once, then verify the specific component supports the capability.

For a complete compiled view with retained state, subscriptions, and overlay layers, read the tested application recipe.

Read the Guides First

Two guides hold the rules this skill assumes. They are requirements, not inspiration. Read the guide file itself; do not answer from this page, from a similar file in the codebase, or from training data.

GuideRead before
Design Guides, skill gpui-kit-design-guidesChoosing components, layout, spacing, hierarchy, color, density, interaction states, overlays, motion, interface copy
Coding GuidesCrate layering, RenderOnce vs Entity<T>, state ownership, ElementId, events, focus, async, public API, naming, testing

Read the Design Guides first when the change has a visible surface: code structure preserves product intent, it does not replace it. If the design skill is not installed, fetch https://gpui-kit.com/docs/design-guides.md. The coding guide is a verbatim copy of https://gpui-kit.com/docs/coding-guides.md, so its links to ./design-guides.md and ./getting-started.md mean the design skill and https://gpui-kit.com/docs/getting-started.md.

Coding Guides section map

Read the whole guide for a new crate, module, or feature. For a narrow change, read "Architecture at a glance" and "Rules for coding agents" first, then the section for the change (grep -n '^## ' references/coding-guides.md).

SectionRead when
Architecture at a glanceAlways; crate layering, ownership boundary
Bootstrap and root ownershipmain, init, Root, window creation, app-level state
Understand GPUI's phases and contextsAnything touching App, Window, Context<T>, render vs update
Choose the right unitDeciding RenderOnce vs Entity<T> vs custom Element
State ownershipWhere a piece of state lives, who mutates it, Entity<State> handles
Stable identityElementId, lists, repeated elements, keyed state
Rendering and compositionrender, builder chains, when/map, child composition
Behavior and presentation boundarygpui-base vs gpui-component vs application code
Theme and stylingcx.theme(), tokens, Styled, sizes, variants
Events, actions, and focuscx.emit, subscribe, actions!, keybindings, FocusHandle
Async work and side effectscx.spawn, background_spawn, Task, I/O, timers
Layout, measurement, and scrollingFlex layout, sizing, overflow, scroll handles, measuring
Lists, tables, and large dataVirtualList, List, DataTable, delegates, large collections
Public API designAnything pub: builders, private fields, setter and reader naming
Platform and capability boundariesmacOS/Windows/Linux/wasm differences, feature gates
File and naming conventionsNew files, modules, type and method names, Kind suffix, Context
Testing strategyWhat to test, #[gpui_kit::test], TestAppContext
Performance rulesRender cost, allocation, re-render triggers
Common failure modesBefore finishing; invented APIs, state in render, index ids
Rules for coding agentsAlways when an agent writes code
Implementation checklistBefore finishing; run every item against the work
Non-negotiables

A floor, not a substitute for the guides.

  • Never invent an API. Search the current source for the real signature. Do not translate a React, CSS, or older-GPUI example by analogy; a plausible-looking method that does not exist is the most common failure.
  • One dependency. Applications depend on gpui-kit alone. GPUI is use gpui_kit::*;; the layers are gpui_kit::component, gpui_kit::base, gpui_kit::assets, gpui_kit::platform.
  • Framework owns behavior, application owns presentation. Do not put colors, sizing, or layout in gpui-base; do not put interaction behavior in application styling code.
  • Stable identity. Repeated elements need domain-derived ElementIds, not list indexes.
  • No pub fields across the seam. Public data types use builders and reader methods.
  • Spell Context out. cx is GPUI's; name anything else after what it holds.

Documentation

  • Find a task/component page: use https://gpui-kit.com/llms.txt, then load its Markdown page.
  • Full reference: https://gpui-kit.com/llms-full.txt is available when broad reference is actually needed
  • Per-component API: fetch https://gpui-kit.com/component/{name}.md, e.g. button.md, input.md, select.md, dialog.md, data-table.md
  • Any site page can be fetched as Markdown by appending .md to the URL

Quick Reference

Setup and examples: references/usage.md.

rust
use gpui_kit::*;

gpui_kit::application()
    .with_assets(gpui_kit::assets::Assets)
    .run(|cx| {
        gpui_kit::init(cx);                       // first, before anything else
        gpui_kit::open_window(options, cx, |window, cx| {
            cx.new(|cx| AppView::new(window, cx))
        })
        .expect("failed to open window");
    });
  • Stateless (RenderOnce): build in render: Button::new("save").primary().label("Save").on_click(|_, _, _| {})
  • Stateful: hold Entity<State> in the view, pass a reference in render: let input = cx.new(|cx| InputState::new(window, cx)); then Input::new(&self.input)
  • Sizes: .xsmall() .small() .medium() (default) .large()
  • Theme: cx.theme().primary · .background · .foreground · .border · .muted
  • Overlays: window.open_dialog(...), open_sheet(...), push_notification(...) via gpui_kit::component::WindowExt

Component Catalog

Import paths are relative to gpui_kit::component::, so input::{Input, InputState} means use gpui_kit::component::input::{Input, InputState};. For the full API fetch the component's .md doc.

Input & Form
ComponentImportNotes
Inputinput::{Input, InputState}Stateful. Text, password, mask, validation
Textareainput::{Textarea, TextareaState}Stateful. Multi-line text
Editorinput::{Editor, EditorState}Stateful. Code editor, tree-sitter feature
NumberInputinput::{NumberInput, NumberInputEvent}Stateful. Numeric with step
OtpInputinput::OtpInputStateful. One-time password
SpeechButtonspeech::{SpeechButton, SpeechState}Stateful. Dictation, speech feature
Selectselect::{Select, SelectState}Stateful. Dropdown picker
Comboboxcombobox::{Combobox, ComboboxState}Stateful. Searchable select
Checkboxcheckbox::CheckboxStateless. on_click receives &bool
Switchswitch::SwitchStateless. Toggle
Radioradio::{Radio, RadioGroup}Stateless.
Sliderslider::{Slider, SliderState}Stateful.
Togglebutton::ToggleStateless.
Ratingrating::RatingStateless.
Stepperstepper::StepperStateless. Multi-step progress
ColorPickercolor_picker::{ColorPicker, ColorPickerState}Stateful.
DatePickerdate_picker::{DatePicker, DatePickerState}Stateful.
TimeFieldtime_field::{TimeField, TimeFieldState}Stateful. Time of day, 24/12-hour
Calendarcalendar::{Calendar, CalendarState}Stateful. Inline month view
Formform::{v_form, h_form, field}Layout container for form fields
Show full SKILL.md (616 more words)Show less
Display & Feedback
ComponentImportNotes
Buttonbutton::{Button, ButtonGroup}Stateless. Primary UI action
Icon{Icon, IconName}Stateless. Lucide icons
Badgebadge::BadgeStateless.
Tagtag::TagStateless. Closable tags
Avataravatar::AvatarStateless.
Labellabel::LabelStateless. Form label
Kbdkbd::KbdStateless. Keyboard key display
Alertalert::AlertStateless. Info/success/warning/error
Spinnerspinner::SpinnerStateless. Loading indicator
Skeletonskeleton::SkeletonStateless. Loading placeholder
Shimmershimmer::{ShimmerText, ShimmerStyle}Stateless. Streaming-text shimmer
Markermarker::{Marker, MarkerVariant}Stateless. Inline status marker
Progressprogress::{Progress, ProgressCircle}Stateless.
Tooltiptooltip::TooltipVia .tooltip() on elements
HoverCardhover_card::{HoverCard, HoverCardState}Stateful.
Clipboardclipboard::ClipboardStateless. Copy button
TextViewtext::TextViewTextView::markdown(id, text), HTML too
Imagegpui_kit::{img, ImageSource, ObjectFit}GPUI's img() element
Overlay & Popups
ComponentImportNotes
Dialogdialog::Dialog + WindowExtVia window.open_dialog(...)
AlertDialogWindowExtVia window.open_alert_dialog(...)
Sheetsheet::Sheet + WindowExtSide panel, via window.open_sheet(...)
Notificationnotification::Notification + WindowExtVia window.push_notification(...)
Popoverpopover::PopoverFloating overlay
Menumenu::{PopupMenu, DropdownMenu}Context menus
DropdownButtonbutton::DropdownButtonButton with dropdown menu
Commandcommand::{Command, CommandState, CommandGroup}Stateful. Command palette
Focus trapFocusTrapElement.focus_trap(id, &handle) on a container; Dialog and Sheet have it built in
Navigation & Layout
ComponentImportNotes
Tabs / TabBartab::{Tab, TabBar}Tabbed interface
Sidebarsidebar::{Sidebar, SidebarMenu, ...}App navigation panel
TitleBarTitleBarWindow title bar
StatusBarstatus_bar::StatusBarWindow status bar
Breadcrumbbreadcrumb::BreadcrumbNavigation breadcrumb
Paginationpagination::PaginationPage navigation
Accordionaccordion::AccordionCollapsible sections
Collapsiblecollapsible::CollapsibleSingle collapsible
GroupBoxgroup_box::GroupBoxLabeled container
Resizableresizable::{h_resizable, v_resizable, resizable_panel, ResizableState}Draggable split panes
ResizeHandleresizable::{resize_handle, HandleEdge}Standalone resize edge
Scrollbarscroll::ScrollbarCustom scrollbar
Data Display
ComponentImportNotes
DataTabletable::{DataTable, TableState, TableDelegate}Stateful. Full-featured table
Diffdiff::{Diff, DiffState, DiffFile}Retained state, RenderOnce element. Readonly unified/Git diff display of one or more files, merge conflicts and source files; application supplies the patch
Tabletable::{Table, ...}Simpler table
VirtualList{v_virtual_list, h_virtual_list}High-perf large lists
Listlist::{List, ListState, ListDelegate}Stateful. Searchable list
Treetree::{Tree, TreeState, TreeItem, TreeEntry}Stateful. Hierarchy
DescriptionListdescription_list::DescriptionListKey-value pairs
Settingssetting::SettingsSettings panel
Chat & Messaging
ComponentImportNotes
Messagemessage::{Message, MessageContent, MessageAlignment}Stateless. Chat message row
Bubblebubble::{Bubble, BubbleContent, BubbleVariant}Stateless. Message bubble
Attachmentattachment::{Attachment, AttachmentContent, ...}Stateless. File/media attachment card
MessageScrollermessage_scroller::{MessageScroller, MessageScrollerState}Stateful. Auto-scrolling message list
Charts
ComponentImportNotes
Chartchart::{AreaChart, BarChart, LineChart, PieChart, RadarChart}Bar, line, area, pie charts
Plotplot::Plot#[derive(IntoPlot)] for data

Testing

UI integration testing means rendering real components in headless windows, simulating input, and checking state, focus, layout and owner callbacks. Use #[gpui_kit::test] to run tests and gpui_kit::test to operate and inspect the UI. When asked to add component interaction coverage, describe it as UI integration testing.

For unit tests, GPUI context tests or UI integration tests, read Testing. It includes dependency setup, a complete runnable UI flow, scoped native interactions, frame/async handling and the limits of accessibility and geometry assertions. Use the production view and verify the action's outcome through normal Rust assertions.

GPUI References

Load the file for the mechanism the task touches. Each file starts with a contents line.

TopicFileLoad when
Actions & keybindingsaction.mdactions!, bind_keys, on_action, key_context
Async & background tasksasync.mdcx.spawn, background_spawn, Task, async I/O
Context managementcontext.mdApp, Window, Context<T>, AsyncApp
Custom elements (low-level)element.mdElement trait, request_layout, prepaint, paint
Entity stateentity.mdEntity<T>, WeakEntity, state management
Events & subscriptionsevent.mdcx.emit, cx.subscribe, cx.observe
Focus & keyboard navfocus-handle.mdFocusHandle, track_focus, Tab navigation
Global stateglobal.mdGlobal trait, cx.set_global, app-wide config
Layout & stylinglayout-style.mddiv(), h_flex(), v_flex(), flexbox, overflow, positioning
ElementIdelement-id.mdElementId, .id(), uniqueness rules, stateful elements
Testingtest.md#[gpui_kit::test], TestAppContext, VisualTestContext

Deep dives, for when the topic file is not enough:

© StudentWeis, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 26 other files (references) in .agents/skills/gpui-kit of StudentWeis/ropy.

  • SKILL.md
  • references/coding-guides.md
  • references/conventions.md
  • references/gpui/action.md
  • references/gpui/async.md
  • references/gpui/context.md
  • references/gpui/element-advanced.md
  • references/gpui/element-api.md
  • references/gpui/element-best-practices.md
  • references/gpui/element-examples.md
  • references/gpui/element-id.md
  • references/gpui/element-patterns.md
  • references/gpui/element.md
  • references/gpui/entity-advanced.md
  • references/gpui/entity-api.md
  • references/gpui/entity-best-practices.md
  • references/gpui/entity-patterns.md
  • references/gpui/entity.md
  • references/gpui/event.md
  • … and 8 more

Open the folder on GitHubat commit 8ab193e

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in StudentWeis/ropy, which our catalogue first saw on October 9, 2026.

Compare with similar skills

Gpui Kit next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Gpui Kit compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Gpui Kit this skillStudentWeis/ropy1951 repos~5.6kAutomated safety check: PassMIT
Ask Sonnerleepokai/Codync1824 repos~1.8kAutomated safety check: WarnApache-2.0
Worklog Designregisx001/Worklog261—~3.3kAutomated safety check: PassMIT
Bezelcrabtalk/bezel171—~1.6kAutomated safety check: PassMIT
UI UX Pro Maxfutureboard/futureboard-studio107—~5.6kAutomated safety check: PassMIT
Pierre Theming Librarypierrecomputer/pierre6.3k—~661Automated safety check: PassApache-2.0

Similar skills

  • Ask Sonner

    leepokai/Codync

    Guide to Sonner, the React toast library — install and wire up the Toaster, pick the right toast() call, promise and loading toasts, updating, dismissing and persisting toasts, styling, theming and…

    182 GitHub starsUsed in 4 repos~1.8k tokens
    Frontend & DesignAuto-check: warnings
  • Worklog Design

    regisx001/Worklog

    Design and UI skill for the Worklog desktop project manager.

    261 GitHub stars~3.3k tokensUpdated 1 mo ago
    Frontend & DesignAuto-check passed
  • Bezel

    crabtalk/bezel

    Build native GUI apps in Rust with bezel, the gpui component library (bezel, bezel-gpui, bezel-ui, bezel-theme, bezel-motion, bezel-icons, bezel-markdown, bezel-editor, bezel-terminal).

    171 GitHub stars~1.6k tokensUpdated 2 days ago
    Frontend & DesignAuto-check passed
  • UI UX Pro Max

    futureboard/futureboard-studio

    Comprehensive design guide for web, mobile, and desktop applications.

    107 GitHub stars~5.6k tokensUpdated 2 days ago
    Frontend & DesignAuto-check passed
  • Pierre Theming Library

    pierrecomputer/pierre

    Explains how to use the @pierre/theming package to list, resolve, select, switch and persist themes, with controller, color and React references.

    6.3k GitHub stars~661 tokensUpdated today
    Frontend & DesignAuto-check passed
  • Store Management

    bkywksj/knowledge-base

    Tauri 状态管理技能,覆盖 React 前端状态和 Rust 后端状态管理. An agent skill from bkywksj/knowledge-base.

    330 GitHub stars~1.2k tokensUpdated 7 days ago
    Frontend & DesignAuto-check passed

More from StudentWeis/ropy

  • Code Quality Review

    StudentWeis/ropy

    Review a code change, diff, pull request, module, or test suite for code quality, comment and documentation quality, and test quality.

    195 GitHub stars~2.2k tokensUpdated today
    Auto-check passed
  • Contribution Flow

    StudentWeis/ropy

    Repository contribution workflow. An agent skill from StudentWeis/ropy.

    195 GitHub stars~705 tokensUpdated today
    Auto-check passed
  • Gpui Kit Design Guides

    StudentWeis/ropy

    The normative Design Guides for GPUI Kit desktop applications.

    195 GitHub starsUsed in 1 repo~1.1k tokens
    Auto-check passed
  • Repo Coordination

    StudentWeis/ropy

    Coordinate concurrent coding-agent sessions through task scopes, progress, and completion.

    195 GitHub stars~1.4k tokensUpdated today
    Auto-check passed
  • Run packaged Ropy desktop GUI end-to-end, smoke, and compatibility tests across macOS, Windows, and Linux.

    195 GitHub stars~1.9k tokensUpdated today
    Auto-check passed
  • Repo Health

    StudentWeis/ropy

    Inspect repository maintainability, robustness, and simplicity without applying fixes.

    195 GitHub stars~1.9k tokensUpdated today
    Auto-check passed

Works with

Questions about Gpui Kit

What does Gpui Kit do?

How to build desktop applications with GPUI Kit, the Rust framework published as the gpui-kit crate (GPUI plus gpuikit::component, gpuikit::base, gpuikit::assets). Gpui Kit is an agent skill from StudentWeis/ropy. How to build desktop applications with GPUI Kit, the Rust framework published as the gpui-kit crate (GPUI plus gpuikit::component, gpuikit::base, gpuikit::assets).

When should I use Gpui Kit?

Gpui Kit fits situations like: setting up a gpui-kit app; using a component (Button; handling component state; window overlays.

How do I install Gpui Kit in Claude Code?

Run `npx skills add StudentWeis/ropy --skill gpui-kit -a claude-code`. Or copy the skill folder (.agents/skills/gpui-kit in StudentWeis/ropy) into .claude/skills/gpui-kit in your project. Claude Code loads it when a task matches its description.

How do I install Gpui Kit in Codex?

Run `npx skills add StudentWeis/ropy --skill gpui-kit -a codex`. Or copy the skill folder (.agents/skills/gpui-kit in StudentWeis/ropy) into .agents/skills/gpui-kit in your project. Codex loads it when a task matches its description.

Can I use Gpui Kit in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add StudentWeis/ropy --skill gpui-kit -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/gpui-kit, .gemini/skills/gpui-kit, .github/skills/gpui-kit and .opencode/skills/gpui-kit in your project.

What does Gpui Kit need to run?

SKILL.md names no scripts, command-line tools or credentials: Gpui Kit is instructions for the agent only.

Does Gpui Kit access the network?

SKILL.md names 1 domain. In commands or code: gpui-kit.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Gpui Kit safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Gpui Kit use?

Gpui Kit is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Gpui Kit use?

About 5.6k tokens (SKILL.md is roughly 22k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 73k tokens, read only when the agent opens those files.

What are the alternatives to Gpui Kit?

Skills that share tags, products or a category with Gpui Kit: Ask Sonner (leepokai/Codync, 182 stars), Worklog Design (regisx001/Worklog, 261 stars), Bezel (crabtalk/bezel, 171 stars) and UI UX Pro Max (futureboard/futureboard-studio, 107 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Gpui Kit?

StudentWeis (a GitHub user) maintains it in StudentWeis/ropy, which has 195 GitHub stars. The repository holds 7 skills in this directory. The repository was last updated on October 9, 2026.

Source: StudentWeis/ropy on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.