Oku Primitives: a Vue port of Radix UI with an honest component status table

Getting the package and seeing it before you install it

There is no install script in this README, because the package is an ordinary npm library, and the project points you at npm and at the documentation site rather than at a step-by-step setup.

The package is @oku-ui/primitives, published on npm, with the version and download badges in the README header linking to the npm package page and the documentation badge linking to primitives.oku-ui.com. The package is ESM, marked type module, and the root package.json requires Node 20 or newer through its engines field, with [email protected] as the package manager for the workspace.

The better first step, though, is not installing. The status table links every component to a storybook story on a vue-primitives.netlify.app instance, with a variant suffix, so you can open a story and see the component behaving in a browser before deciding to take it. The Table of Contents also links a video demonstration and the documentation site covers styling, the component reference and the scripting engines in depth.

Once you do install, the incremental path is the one to take. Import a single component, use it in one screen, and check its keyboard behaviour yourself. The package ships the components individually rather than as one bundle of everything, so you are not committing to the whole set on the first day, and the parts that are not finished are visible in the table before you rely on them rather than after.

The repository also carries a playground/ directory, which is the development harness for trying components against the local build, and a .docs/ directory for the documentation site, so both the published documentation and the examples are built from the same source tree you would clone.

A port, deliberately, rather than a reimplementation

Oku Primitives is described in its repository description as Vue Radix UI Primitives 1:1, components, icons, colors, and templates for building high-quality, accessible UI.

That 1:1 is the defining decision, and it is worth understanding what it buys and what it costs. Radix UI is a well-known set of unstyled, accessible primitives for React, and the Oku project's approach is to port that set to Vue rather than design a new one. The README says Oku Primitives is a low-level UI component library with a focus on accessibility, customization and developer experience, and that you can use these components either as the base layer of your design system or adopt them incrementally.

The incremental adoption point matters more than it sounds. A component library is usually an all-or-nothing proposition: you take the button, you take the theme, you take the styling approach, and your app now looks like the library's demo. A primitives layer is different, because the components are unstyled behaviour with the accessibility built in, so you can take one of them, the accordion or the dialog, and keep your own visual design entirely.

The alternative to this project is not another Vue component library. It is writing the behaviour yourself, which means focus trapping in dialogs, roving tabindex in menus, keyboard dismissal, aria wiring and portal rendering, each of which is a known source of accessibility bugs that are tedious to get right and easy to get wrong. Oku's claim is that the port gives you the tested version of that behaviour in Vue.

The primary language is Vue, the licence is MIT, and the default branch is main. The documentation site is primitives.oku-ui.com, and the wider project has a website at oku-ui.com and a Discord community.

The status table tells you which components are actually finished

The most useful thing in this README is not prose. It is a table of every component with five columns, and it is unusually honest about what is not done.

The columns are Component, Status, Hook v1, Visual Check, Test and Note. The Status column uses three values across the list: Completed for most of the set, In Progress for NavigationMenu and Select, and Not Started for Form.

The rows give a sense of scale. Completed and hooked are Accordion, AlertDialog, AspectRatio, Avatar, Checkbox, Collapsible, Context Menu, Dialog, DropdownMenu, HoverCard, Label, Menubar, Popover, Progress, RadioGroup, ScrollArea, Separator, Slider, Switch, Tabs, Toast, Toggle, ToggleGroup and Toolbar. The storybook links in the table point at a vue-primitives.netlify.app story for each one, with a variant suffix, so you can see the component in a running playground before you install anything.

The other three columns are the interesting part, because they track different kinds of completeness. A component can be implemented and still fail a visual check, and the Note column records the specific gaps. HoverCard carries the note that it needs polygon and a close fix. Checkbox, RadioGroup and Switch are marked as needing input. Avatar records a pull request from Radix, which is a pointer to the upstream source of that particular component.

The Test column is almost entirely empty, which is the honest signal in the table. Only Label, Progress and a few others have a test mark. A primitives library whose value is accessibility, where the tests are not yet written across the board, is a project to approach with your own test budget rather than with an assumption that the behaviour is verified.

The README also states the contribution rule plainly: enter the component you want most in the components list, leave the emojis and follow, and developers can work on unclaimed components. The table is therefore also a task board, and the existence of an empty Test column tells a reader which of those tasks have real value.

The monorepo behind the package, and how it is built

The repository is a pnpm workspace with a lot of moving parts, and reading the package.json is the fastest way to understand how it is put together.

The root package is @oku-ui/primitives, marked private, at version 0.7.8, with [email protected] as the package manager and Node 20 or newer required through the engines field. The build is orchestrated by Turborepo, with the build script running pnpm turbo build, and Nx is also present, with nx.json and turbo.json at the root and scripts that run nx run-many for skipping the cache and for cleaning.

Testing is Vitest, with a plain vitest run for the unit suite, a watch mode, a Nuxt-specific configuration in vitest.nuxt.config.ts used by the test:nuxt script with coverage, and a separate coverage script. There is a vitest-setup.ts file for shared setup. Linting is ESLint with the @antfu/eslint-config from the catalog, and Storybook is present with a .storybook/ directory, a story script that runs storybook dev on port 6006 without opening a browser, and a build:storybook script.

The workspace also has a .docs/ directory for the documentation site, a playground/ directory, packages/ holding the published packages, and a scripts_c/ directory with TypeScript scripts for dev and for updating versions. The publish flow is in the root scripts: pub:release, pub:beta and pub:alpha all change into packages/core and run its release script, and a scripts:genpackage script generates alias code.

Two details are worth noting for anyone tracking versions. The devDependencies list @oku-ui/primitives itself as a workspace dependency, which is how the playground and docs consume the local build. And a bumpp script updates the version across package.json, packages/*/package.json and .docs/package.json together, so the root manifest, the core package and the docs stay in step, which is the kind of detail that prevents a monorepo from shipping mismatched versions.

Adopting it incrementally, and the gap that will bite you

The README's own framing is that you can use the components either as the base layer of your design system or adopt them incrementally, and that is the recommended path for most teams.

Incremental adoption works because the components are primitives. The README's badge links point at the npm package @oku-ui/primitives, and the storybook links show a styled variant for most components, which is the point: the behaviour is fixed and the appearance is yours. A dialog gives you the focus trap, the escape handling, the aria-modal wiring and the portal, and you bring the CSS.

The gap that will bite you is in the table, and it is worth planning around. Form is not started. That is the component set you need for any non-trivial form, and NavigationMenu and Select are in progress, which means their hook is marked in progress rather than complete. If your design system needs a select, a navigation menu or a form, this library does not yet cover it, and the note column shows that even some completed components still have known gaps, HoverCard among them.

The second gap is test coverage. The Test column is mostly empty, and for a library whose entire argument is accessibility, that is the gap that matters most. You are trusting the port to have reproduced Radix's behaviour correctly, and for many components that reproduction is untested in this repository.

So the sensible adoption pattern is narrow and verified. Take a component whose behaviour you can check yourself, a dialog or a tabs, wire it into one screen, and test the keyboard path by hand. Do not rebuild a form system on it this week.

The alternatives are worth naming clearly. The real one is Radix UI itself, which is the upstream project, and it has the same design and the same behaviour, in React rather than Vue, and a far larger body of published work behind it. If your application is React, the port is not a reason to move. If your application is Vue, this is the closest equivalent, and the incremental path is the same one Radix offers.

A release from 2024, a repository pushed to this week

On maintenance, the picture has two layers that do not agree with each other.

The repository is not archived and the last push was on 2026-10-17, on the main branch, so the code is being worked on within days of this review. The version in package.json is 0.7.8.

The recent releases, however, are v0.7.8 from 2024-12-01, v0.7.7 from 2024-12-01 and v0.7.6 from 2024-11-30. Three releases inside three days, and then nothing published for roughly two years.

That is the shape of a project where the code moves but the published artefact does not. The 0.7.x line is what npm serves, so an installer today gets the code as it stood in December 2024, not the code in the repository today. If the work since then added components or fixed behaviour, the difference between the installed package and the repository is a real gap you would have to close by installing from source or from a branch.

There is also a version-0.x signal. The library is pre-1.0, so there is no compatibility promise across minor versions, and the status table's own vocabulary of Completed, In Progress and Not Started is the kind of tracking you expect from a project that has not yet declared its API stable.

The licence is MIT, with a LICENSE file at the root of the tree, and the README links a contributing guide. For a design system foundation, MIT means you can take these components into a commercial product and change them freely, which is the usual reason to choose a primitives layer over a paid kit. This review does not interpret the licence terms.

So the honest summary is: an active repository, a published package that is a couple of years behind it, a component set that is largely but not entirely complete, and an accessibility argument that is compelling in principle and only partly backed by tests in this repository.

Editorial conclusion

Oku Primitives fits a Vue team that wants Radix-style accessible primitives without maintaining its own focus management and keyboard handling, and the per-component status table means you can pick only the parts that are actually finished. It is the wrong choice if you need the missing pieces now, since Form is not started and NavigationMenu and Select are in progress, and it is the wrong choice if you want a versioned, stable dependency, because the newest tagged release is v0.7.8 from 2024-12-01 even though the repository was pushed to on 2026-10-17. Before you adopt it, read the component status table in the README and check the Hook v1 column for the components you plan to use, and confirm the version you install matches the branch you are reading about.

Frequently asked questions

Official sources

1. License: MIT
2. oku-ui/primitives on GitHub
3. Project website
4. README
5. Releases