I’m leaning towards vendoring for all my new projects.

Grabbing an off-the-shelf UI library is easy in the short term, but it’s usually overcomplicated, implements things I won’t ever need, is hard to tweak if/when you want to distinguish your app from the thousand others using the same library, and when you do decide to upgrade it, all your tweaks break in subtle ways.

What I think would be the best approach is building your own UI library. You own it, you get to reuse it across different projects and maintain the same visual style (if desired), and you add features when you need them.

If you don't need to make any changes, it should be very simple to just upgrade by replacing the components. And if you need to make changes then well it's not gonna work with a traditional UI library.

Mantine is brilliant, I can build anything in it quickly and then extend it or completely customize the theme or individual components, but there is a learning curve. I would not call it a giant learning curve.

I highly prefer a copy and paste approach. The less npm installs the better.

Martine just straight up sucks.

Vendoring your components gives you the best of both worlds. You get a full component library but retain the ability to modify them as you want.

Your AI agent claim doesn't make any sense either. When upgrading normally your component just gets rewritten on disk. When switching from radix to base ui, a more comprehensive approach is needed.

My main gripe with Shadcn and, well, most UI libraries nowadays, is that they are reinventing the wheel for like a thousandth time.

I’m trying out Ark UI on a side project. They do have some genuinely useful components, like tags input: https://ark-ui.com/docs/components/tags-input

They have a tabs/“segment group” component with a nice animated active element indicator which would probably be tricky to implement: https://ark-ui.com/docs/components/segment-group

And then they also have stuff like overcomplicated “click to copy” button and a <details> reimplementation: https://ark-ui.com/docs/components/clipboard, https://ark-ui.com/docs/components/collapsible

All with a verbose markup that renders as a div soup.

How about leveraging llms to produce deterministic codemods? You can then iterate on this by running the codemods and using other deterministic guardrails, feeding the results back into the llm to improve the codemods?

I think the two complement each other perfectly and will continue to do so. I keep writing AGENTS.md files for soft rules and custom linter rules for hard ones which IMO is the best of both worlds.

Base UI is more low-level, a lot less opinionated and doesn’t force you into certain layouts. This of course makes it more complex to use, but that doesn’t matter if you’re using shadcn components because they’re doing that work for you.

So essentially they look and operate the same as Radix components at the shadcn level but you have low-level control later on should you need it.

What's the difference?

All of these component libraries look the same.

Both attempts[1] to surface this on HN failed but if you are using a PrimeTek component library you need to be aware of this change.

PrimeNG, PrimeReact, and PrimeVue are all impacted and ongoing licencing will be $800 per developer seat in 2027. It's not just the pro add-ons either this covers the core components too. [2]

The previous repos have all be archived [3]

PrimeFaces remains open source but it's now developed and maintained by independent volunteer developers who are not employees of PrimeTek.

[1]: https://hn.algolia.com/?q=The+Next+Chapter+of+PrimeTek

[2]: https://primeui.dev/nextchapter

[3]: https://github.com/primefaces/primeng