Let’s be real: using most modern UI libraries feels like they were built by and for teams with 100+ engineers… not everyday devs trying to get something shipped.

Over the years, I’ve worked with almost every major library out there. And while many are polished, they’re not always practical. So I decided to build my own — introducing Elementrix-UI.

But first — let’s talk about what’s broken.

A Quick History: Why These Libraries Were Built

Most of today’s popular UI libraries were born out of specific needs at a specific time.

  • MUI (Material-UI) started as a faithful implementation of Google’s Material Design for React, aiming to bring visual consistency and accessibility to apps.
  • Chakra UI focused on developer experience and accessibility out of the box — a breath of fresh air when other libraries were verbose or rigid.
  • Ant Design was designed for enterprise-scale dashboards, prioritizing dense UI with built-in patterns for data-heavy apps.
  • Tailwind UI came from the success of utility-first CSS, answering the demand for speed and visual cohesion in frontend design.

They all had valid use cases — and still do in the right contexts.

But here’s the issue:

They were built for specific stacks, specific workflows, and specific assumptions that don’t scale well across projects, teams, or frameworks.

And today’s dev world? It’s messier (and more exciting) than ever:

  • Teams hop between React, Vue, Angular, and even Astro or Svelte.
  • Micro frontends are the norm.
  • Design systems need to outlast individual projects.
  • Solo developers need to move fast without spending a week configuring themes or wrangling state logic.

The result?

You hit a wall — fast.

Most libraries box you into their way of doing things… and getting out takes more effort than just building the thing yourself.

The UI Component Landscape: Pros & Cons

Here’s a quick rundown of some of the most widely used UI libraries today, what they offer, and where they fall short.

🧩 MUI (Material-UI)

  • Pros:
    • Polished and production-ready components
    • Extensive documentation
    • Built-in accessibility
    • Strong React community
  • Cons:
    • Tightly coupled to React — can’t use outside the React ecosystem
    • Styling can be over-engineered and opinionated
    • Theming often feels like wrestling with the library, not working with it

🎯 Chakra UI

  • Pros:
    • Developer-friendly syntax
    • Built-in accessibility
    • Consistent design principles
  • Cons:
    • React-only — no support for other frameworks
    • Component flexibility sometimes limited to “the Chakra way”
    • Doesn’t scale well into large enterprise systems

📦 Ant Design

  • Pros:
    • Huge component collection
    • Enterprise-grade feel
    • Rich table and form support
  • Cons:
    • Heavy bundle size
    • Style customization is a pain
    • Localization and design language can feel overly rigid

🛠 Tailwind UI

  • Pros:
    • Great for utility-first devs already using TailwindCSS
    • Beautiful, responsive layouts
    • Rapid prototyping
  • Cons:
    • Not a component library — it’s HTML+Tailwind snippets
    • No interactivity (you wire up logic yourself)
    • No state handling, accessibility is up to you

🌐 Shoelace

  • Pros:
    • Web component-based (yay!)
    • Framework-agnostic
    • Easy to integrate in micro frontends
  • Cons:
    • Minimal component variety
    • Doesn’t support design system scaling
    • Documentation and adoption are still limited

So I Built: Elementrix-UI

After years of wrestling with those limitations, I decided to build Elementrix-UI — a UI system that works the way developers actually need it to.

I wanted something:

  • Fast
  • Customizable
  • Easy to use
  • Framework-agnostic
  • Scalable from a solo dev to full product teams

Elementrix-UI is my answer to all the above. Here’s what I’m doing differently:

  • ✅ Built on StencilJS for true Web Component support (works everywhere)
  • ✅ Full TypeScript support
  • ✅ Styled with SCSS and exposed CSS variables for theming
  • ✅ Based on Atomic Design — scale components from atoms to templates
  • ✅ Maintained by an open community (not a corporate roadmap)

It’s designed to grow with the developer, not trap them in a silo.

⚖️ The Real Comparison

Let’s break it down:

| Feature                  | Elementrix-UI                    | MUI / Chakra / Ant / Tailwind UI |
|--------------------------|----------------------------------|----------------------------------|
| Framework Support        | ✅ Works with React, Vue, Angular, JS | ❌ Usually React-only             |
| Language                 | ✅ TypeScript                     | ⚠️ Mixed JS/TS                   |
| Customization            | ✅ CSS variables, SCSS, override anything | ❌ Often overly complex          |
| Design System            | ✅ Atomic Design, scalable        | ⚠️ Varies, often inconsistent     |
| Theming                  | ✅ Straightforward & flexible     | ❌ Deep config / tokens required |
| Bundle Size              | ✅ Lightweight via StencilJS      | ⚠️ Varies, often bloated          |
| Community Input          | ✅ Built from user feedback       | ❌ Mostly roadmap-locked          |
| Usage Goals              | ✅ Indie to Enterprise-ready      | ⚠️ Usually geared toward large teams |

Why “Framework-Agnostic” Actually Matters

When you’re building a UI system, one of the worst decisions you can make is locking yourself into one ecosystem.

  • What happens when your team moves from React to Vue?
  • What if you want to use something in Webflow, WordPress, or Astro?
  • What if you want your design system to outlive your current framework?

Most UI libraries break completely in that scenario.

By using Web Components, Elementrix-UI runs natively in every major framework — without rewriting your entire UI. It’s the write-once, drop-anywhere approach that just makes sense.

Built for Developers — By a Developer

Elementrix-UI isn’t some VC-funded, 12-person team project. It’s just me — a solo dev running a registered LTD — working hard to build a better UI system with the community.

I'm building in public, taking feedback from Patreon supporters, and shaping features around what developers actually want (not what’s easiest to maintain).

That means:

  • 💬 Regular input on what components get prioritized
  • 🎨 Shared visual direction for the design language
  • 🧱 Clean architecture that doesn’t fight your stack
  • 🔧 Easy overrides, so you don’t need to fight the theme engine just to change a color

TL;DR

If you’re tired of over-engineered UI kits, React-only silos, and configuration jungles — I feel you.

Elementrix-UI is my response.

It’s:

  • Fast
  • Framework-agnostic
  • Customizable
  • Built around real developer pain points

The MVP is in development, and we’re opening it up with community support through Patreon.

👉 Check out the live website: elyndrastudios.com

👉 Follow for updates: @elyndrastudios

💭 Your Thoughts?

  • What’s your biggest complaint with current UI libraries?
  • What component always ends up needing a total rewrite?
  • What does “ideal” look like to you?

Hit me up in the comments 👇 — I’m building this for devs like you.