Skip to content
Skills Library
Programming · Building & coding

solid-floating-ui

/solid-floating-ui

Build floating elements in a SolidJS project with solid-floating-ui: tooltips, popovers, dialogs, selects and comboboxes, dropdown and nested menus, context menus, cursor-following elements, composite toolbars and grids, enter and exit transitions, and shared hover delay groups. Carries a complete working recipe for each, plus the reactivity rules that keep the hooks live. Use when the user asks for any anchored or overlay UI in SolidJS, mentions solid-floating-ui or @floating-ui, or is porting a pattern from @floating-ui/react.

Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
13
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Build floating elements in a SolidJS project with solid-floating-ui: tooltips, popovers, dialogs, selects and comboboxes, dropdown and nested menus, context menus, cursor-following elements, composite toolbars and grids, enter and exit transitions, and shared hover delay groups. Carries a complete working recipe for each, plus the reactivity rules that keep the hooks live. Use when the user asks for any anchored or overlay UI in SolidJS, mentions solid-floating-ui or @floating-ui, or is porting a pattern from @floating-ui/react.

Original author description

Build floating elements in a SolidJS project with solid-floating-ui: tooltips, popovers, dialogs, selects and comboboxes, dropdown and nested menus, context menus, cursor-following elements, composite toolbars and grids, enter and exit transitions, and shared hover delay groups. Carries a complete working recipe for each, plus the reactivity rules that keep the hooks live. Use when the user asks for any anchored or overlay UI in SolidJS, mentions solid-floating-ui or @floating-ui, or is porting a pattern from @floating-ui/react.

How it works

  1. Pick the recipe
  2. The four rules that break everything when broken
  3. Install
  4. Check the work
Original SKILL.md headings · 50 lines, 412 words
SKILL.md preview
---
name: solid-floating-ui
description: >
  Build floating elements in a SolidJS project with solid-floating-ui: tooltips,
  popovers, dialogs, selects and comboboxes, dropdown and nested menus, context
  menus, cursor-following elements, composite toolbars and grids, enter and exit
  transitions, and shared hover delay groups. Carries a complete working recipe
  for each, plus the reactivity rules that keep the hooks live. Use when the user
  asks for any anchored or overlay UI in SolidJS, mentions solid-floating-ui or
  @floating-ui, or is porting a pattern from @floating-ui/react.
---

Build the thing from the matching recipe. Do not improvise the wiring.

## Pick the recipe

| The user wants                                          | Read                        |
| ------------------------------------------------------- | --------------------------- |
| Hover or focus label on a control                       | `reference/tooltip.md`      |
| Click-triggered panel anchored to a button              | `reference/popover.md`      |
| Centred modal with a backdrop                           | `reference/dialog.md`       |
| Listbox, select or combobox with keyboard navigation    | `reference/select.md`       |
| Dropdown menu, submenus, menu bar                       | `reference/menu.md`         |
| Right-click menu                                        | `reference/context-menu.md` |
| Element that follows the pointer                        | `reference/cursor.md`       |
| Toolbar, tab list or grid with arrow keys, not floating | `reference/composite.md`    |
| Fade or scale the element in and out                    | `reference/transition.md`   |
| A row of tooltips sharing one delay                     | `reference/delay-group.md`  |
| A pointer or arrow on the floating element              | `reference/arrow.md`        |

Read `reference/api.md` first whenever the task is not a straight copy of one
recipe, or when something built from a recipe is not updating.

Combine recipes freely. They share one shape, so a select inside a dialog is
the two files' hooks passed to one `useInteractions`.

## The four rules that break everything when broken

1. **Options are getters.** Anything that changes is `get open() { return open(); }`, never a captured value and never destructured. You never declare what an option depends on.
2. **Return values are getters too.** Keep the object and read through it where the value is used: `floating.placement`, not `const { placement } = floating`.
3. **Accessors in, callbacks out.** Anything the library reads from you takes `() => T`: `items`, `labels`, `scrollElement`, the `arrow` element, a portal `root`, `initialFocus`, `returnFocus`. Anything it produces arrives through a callback: `onElementsChange`, `onLabelsChange`, `onVirtualItemChange`, `onOverflowChange`. There are no ref containers.
4. **Spread the prop getters once.** `{...interactions.getFloatingProps()}` in the markup stays live on its own. Never call it inside a loop; that is what `getItemProps` is for.

## Install

```bash
pnpm add @floating-ui/dom solid-floating-ui
```

`@floating-ui/dom` and `solid-js` are peer dependencies. The package ships JSX
uncompiled through the `solid` export condition, so a Vite project using
`vite-plugin-solid` needs no extra configuration.

## Check the work

- Does every changing option go through a getter?
- Is `useDismiss` present? Almost every floating element needs it.
- Is `useRole` present? It supplies the ARIA wiring the pattern needs.
- Is the element inside `FloatingPortal` when an ancestor clips or stacks it?
- Does an interactive element have `FloatingFocusManager` around it?
Files in this package (13)
  • SKILL.md 4 KB
  • reference/api.md 7 KB
  • reference/arrow.md 2 KB
  • reference/composite.md 2 KB
  • reference/context-menu.md 3 KB
  • reference/cursor.md 2 KB
  • reference/delay-group.md 3 KB
  • reference/dialog.md 3 KB
  • reference/menu.md 7 KB
  • reference/popover.md 3 KB
  • reference/select.md 6 KB
  • reference/tooltip.md 3 KB
  • reference/transition.md 2 KB

Versions

The database has no other skills named solid-floating-ui.

Database snapshot: 13.11.2026 · package version 6e2969a161eb (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90frontend-solidjs-architecture
    Use this skill when the user says 'SolidJS', 'SolidJS architecture', 'Solid signal', 'Solid component', 'Solid reactivity', 'SolidJS app', 'Solid router', 'SolidJS vs React', 'SolidJS fine-grained'. This skill enforces: fine-grained reactivity via Signals/Memos/Effects, compiled…
  • 90solid-js-expert
    Use when SolidJS or SolidStart reactivity, routing, server/client boundaries, data mutation, component semantics, or React migration determines the solution.
  • 100solid
    SolidJS renderer for json-render. Use when building @json-render/solid catalogs/registries, wiring Renderer providers, implementing bindings/actions, or troubleshooting Solid-specific reactivity patterns.
  • 90frontend-solidjs-patterns
    Use this skill when the user says 'SolidJS pattern', 'SolidJS form', 'SolidJS data fetching', 'SolidJS component pattern', 'SolidJS animation'. This skill enforces: createResource for async data with Suspense, controlled forms via signals, component composition via JSX children…
  • 100solid
    SolidJS reactive UI library. Covers signals, effects, and fine-grained reactivity. USE WHEN: user mentions "SolidJS", "Solid", "createSignal", "createEffect", "createMemo", "fine-grained reactivity", asks about "Solid patterns", "reactive primitives" DO NOT USE FOR: React - use…
  • 100intlayer-solid
    Integrates Intlayer internationalization with SolidJS components. Use when the user asks to "setup SolidJS i18n", create a new translated component, use the "useIntlayer" hook in Solid, or configure providers.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.