DEV Community: Alex Smith

Utility Classes Won 2026. I'm Still Betting on Bulma.

Alex Smith — Fri, 25 Sep 2026 03:27:38 +0000

It's 2026, and the CSS framework debate is Tailwind vs. Tailwind. shadcn/ui or DaisyUI? Keep your v3 config or move to v4's CSS-first setup? Bootstrap isn't in the conversation anymore. It's the thing still running your admin panel.

Utility classes won. I'll say it plainly.

But I think they won this round. The next one goes to the idea they replaced, object-oriented CSS, and Bulma is already standing where that pendulum is headed.

The button test

A primary button in Tailwind:

<button class="inline-flex items-center rounded-md bg-indigo-600 px-4 py-2 text-sm font-semibold text-white shadow-xs hover:bg-indigo-500 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-indigo-600">
  Save
</button>

The same button in Bulma:

<button class="button is-primary">Save</button>

Yes, you'd wrap the Tailwind version in a component. That's my whole point.

Even Tailwind users are rebuilding objects

Back in 2008, Nicole Sullivan's OOCSS laid out a simple idea: separate structure from skin. You build a reusable object (.button), then layer skins on top (.is-primary, .is-large).

Now look at what the Tailwind ecosystem built next:

DaisyUI, one of Tailwind's most popular plugins, exists to give you btn btn-primary.
shadcn/ui hides its utility strings behind a variant prop. The API everyone actually touches is <Button variant="destructive">.
@apply is still there for every team that wants .card back.

That's OOCSS, reinvented in a plugin and a component layer. Bulma's button is-primary is the same idea, with no build step and nothing to wrap.

Modern CSS fixed what pushed us to utilities

Utilities took off because global CSS was painful. We had specificity wars, styles leaking across the app, and no real way to scope anything.

Plain CSS has mostly solved that. Cascade layers, native nesting, :where(), container queries, and custom properties now work in every major browser.

Bulma v1 was rebuilt for that world.

CSS variables everywhere. You can rebrand without a build step:

:root {
  --bulma-primary-h: 262deg;
  --bulma-primary-s: 80%;
  --bulma-primary-l: 50%;
}

Dark mode built in. It follows prefers-color-scheme automatically. You can also force it with data-theme="dark".

Skeleton loaders. A single is-skeleton class turns an element into a loading placeholder.

A smart grid. The new grid and cell classes sit alongside the classic flexbox columns.

Zero JavaScript, verified

Bulma is pure CSS; its npm package doesn't contain a single .js file. Tailwind is also zero in the browser, since it's a build tool with no runtime. The old guard is a different story.

Here's what each framework ships if you use its interactive components (dropdowns, modals, tooltips):

Framework	JS shipped (min + gzip)	Notes
Bulma 1.0.4	0 KB	Pure CSS
Tailwind 4.3	0 KB	Build-time only
Bootstrap 5.3.8	~24 KB	Bundle with Popper (~16 KB without)
UIkit 3.25	~53 KB	Plus ~21 KB for the icon set
Foundation 6.9	~67 KB	~40 KB, plus the jQuery it requires

Measured from the latest npm packages, September 2026. Foundation hasn't shipped a release since 2024.

This matters more every year. Server Components are the default in the Next.js App Router, and every kilobyte of client JavaScript has to justify itself. A stylesheet has nothing to hydrate.

The honest trade-offs

The full build isn't tiny. The all-in bulma.min.css is about 65 KB gzipped, because it ships every color, every shade, every helper, and the dark theme. Bulma's modular Sass fixes that: import only what you use. A realistic app build (buttons, forms, navbar, cards, modal, dropdown, columns, spacing helpers) came in around 36 KB gzipped in my test.

You bring your own interactivity. Bulma styles a modal or a dropdown, but it doesn't open one. In vanilla JS that's a few lines. In React, it's where a component library earns its keep. I got tired of rewriting the same is-active toggles on every project, so I built one: bestax-bulma, a fully typed React library for Bulma v1 (full disclosure: I maintain it).

The ecosystem is smaller. There are fewer themes and fewer plugins, and your AI assistant has seen far more Tailwind than Bulma. The class names are plain enough that it rarely matters.

When I'd still pick Tailwind

Pick Tailwind if your team already thinks in utilities and ships with shadcn/ui; switching costs are real. It's also the better call if you're building a fully bespoke design system where no framework's defaults would survive anyway.

Bootstrap? Only if you're maintaining something that already uses it.

Try it in 30 seconds

<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bulma@1.0.4/css/bulma.min.css">

Drop that into a CodePen, write <button class="button is-primary">, and see how far you get before you miss anything.

Utility classes won this round. The next one goes to CSS that reads like English, and Bulma has been writing it since 2016.

Me Dealing with AI Training Bias

Alex Smith — Fri, 25 Sep 2026 03:27:11 +0000

This started for me in 2024, when Bulma v1 came out. I went looking for a React package that supported it. There wasn't one yet.

The packages people already knew were still on the older Bulma, and from where I sat they looked dormant. So I decided to fill that gap. I worked on it until I had what I considered a minimum viable product, and then I started trying to get the package recognized and used.

What I Tried First

That effort was 2025. I wrote a real README, for npm and for GitHub, and I treated it like the front door. I posted about the package. I posted on Reddit. Between posts I kept enhancing it, small improvements, the kind of work you do when you figure the next person who comes looking should find something obviously worth using. I was pretty sure people would go looking.

They mostly didn't. As I write this in September 2026, the repo has eleven GitHub stars. This still sucks...!

I also spent a lot of 2025 on being findable in the usual places. SEO, so Google would surface the site. Cloudflare in front of it, so the docs would be fast. A docs site I put a ridiculous number of hours into, then went back and polished again. Blog posts, here and on dev.to and Medium. I'd publish something, check whether anyone had noticed, and wait. Still not much traction. It was disappointing. I had talked myself into thinking it would take off if I kept doing the work, and it didn't.

Early 2026

In 2026 I revamped how I was approaching the library. Early in the year I started the major redo of the forms. The big release of that work landed in June, but the redo itself started in those first months.

I kept going, like the tortoise in that race. Slow and steady, and I didn't give up.

That's when I got serious about not being a dumb wrapper. If someone already knows the classes, a thin package doesn't give them a reason to bother, and I was starting to feel that. I spent those months on the parts a real app needs. The forms redo was the long one. Around it I built things Bulma doesn't ship, a carousel, dialogs, toasts, an avatar, that kind of thing. I was trying to make a full component library, closer to MUI than to a handful of bindings. A lot of nights. I didn't know yet that doing all of that still wouldn't matter to a model.

I wrote a couple more posts. The dev.to and Medium pieces were part of that. I built more of the docs, and then I went back over them and refined them.

Asking the Models What They'd Use

By summer I had two explanations, and I still go back and forth on them. One is that people just aren't using Bulma much anymore. I don't think the project is abandoned. The repo still gets fixes. A framework can be maintained and still not be what anyone reaches for. The other explanation is that people have moved over to AI, and if that's how they're picking tools now, then the old ways of getting someone to notice a package don't work the way they used to.

Articles were coming out about search itself changing. In July 2025 Pew Research Center looked at real Google visits. When the results page had an AI summary, people clicked a normal result 8% of the time, compared with 15% when there was no summary. They were also more likely to end the session on that page, 26% versus 16%. The answer was sitting there, and a lot of people never went further. I don't have a study like that for npm. What I do know is I had been counting on people to search, click, and read, and I don't think they sit down with an article about a library when a model will write the integration. Looking at eleven stars, that felt less like a theory and more like my year.

So I started testing it. If people are mostly using AI, then maybe the AI is the thing finding libraries, and maybe people aren't trying new ones because the model picks for them. I opened chats and asked what it would use to build a web app, and what it would start a new project with.

It surprised me. React, still, which was good. That's what I built for. Then it steered me toward Tailwind. Then toward shadcn/ui. I'd close the chat, phrase it a different way, and it would steer me there again. MUI and Mantine weren't the default either, which was interesting, because I'd been building toward that kind of library all year.

When I asked for a new Bulma project, it recommended react-bulma-components. That package last published 4.1.0 in February 2022, and it still targets Bulma 0.9. It recommended that over mine, and over newer libraries like reactive-bulma and trunx. Both of those were still publishing releases in September 2026. The models were reaching for the old name.

Then it got weirder, and maybe "weirder" is the wrong word, but it felt weird to me. A lot of the answers said to skip the component library. Use Bulma's classes. Wrappers might be a dead end. Most people have a perfectly fine time writing the classes straight into the markup. And bestax-bulma often wasn't in the answer at all. It didn't seem to know the package existed.

I asked what I could do so it would at least see bestax as a choice. The answer was the unexciting one. Keep doing the things you'd do for people in a world before this. The README, the posts, the docs. I was already doing that. I kept at it.

What I kept hearing, when I asked again, was that training data on the popular stuff is why one-shotting and few-shotting works. The model has seen that library so many times that it already knows what a decent file looks like.

The Source Code Was the Shock

I tried some prompts of my own. The sites looked sort of okay. Not polished, not really attractive, and I know it can look better than that because I've built the screens. The shock was the source. It was messy. A lot of it was Bulma classes, written out by hand, instead of my components. A tooltip built from scratch. An avatar that was basically a div with a background. I don't think it was rejecting the library. The training data is thin, so it doesn't really know what to use.

There's a stale version of the same problem. A model trained in the spring has never seen a component I shipped in July. And even a model that met bestax once met an older bestax. The package has grown since then.

A Summer of Trying Things

I asked what I could do to help. It suggested a few things. llms.txt, since I already had the docs on Docusaurus. Skills. And an MCP server. So, still in the summer, I started building those. I was tired, and I did it anyway.

llms.txt was the easy one, and I was grateful, because nothing else that year had been easy. I turned on docusaurus-plugin-llms. The build writes a short index, the docs as one big file, and a markdown copy of each page, and it does that again on every deploy, so this particular thing can't drift away from me. That was the whole win. It did not make the models know the library.

I also made sure robots.txt was set up. It carries a content signal, search=yes, ai-input=yes, ai-train=yes. Search means building an index. ai-input means a model can use the page when it's answering. ai-train means training. Some people would turn the training one off. I want this library in the next round of training data, so I left all three on.

Then I turned on Cloudflare's Markdown for Agents. The switch is under AI Crawl Control. When a client sends Accept: text/markdown, Cloudflare converts the HTML and answers with content-type: text/markdown. Their writeup says agents like Claude Code already send that header. I checked this site, and the LLMs guide does come back as markdown. The plugin's files are the clean docs, which is what I want sitting in a context window. Cloudflare's conversion is the rendered page, nav and everything. A little messy. I kept both, because different agents show up in different ways.

Skills were harder, and they stung more, because I could watch them almost work. I wrote them, generated a site, and the result was still wrong. So I did that again, and again, rewriting the skill each time. A skill is just a folder of instructions an agent can load. I ended up with a handful, layout, forms, theming, icons, and a few others. Knowing the props is not the same as knowing how you actually want a page built. The early ones taught me that by failing. The loop did help. It just never helped all the way.

One thing I watched more than once was an agent happily building its own tooltip while mine was already there, shipped and documented. That one hurt. A wrong prop at least shows up in the type checker. A homemade component kind of works, and then you own it. I started putting a generated list of every component at the front of one of the skills, just the name and a line about what it's for. CI fails now if something ships without a docs page, because that's what the list is built from. I learned the hard way that if the agent can't see it, the agent will rebuild it.

Even with the skills, it didn't always use them. I'd ask it to build something and it would just go off on its own. I asked what it was actually using. It said the types.

That sent me back into the code, which was a humbling place to end up after all the docs work. The comments on the types weren't very good, so an agent reading TypeScript was reading a weak version of the library. I rewrote them. On this project those comments also generate the props tables, so fixing them fixed both, and I wish I had noticed sooner. If you maintain a package, this is the part that got me. The comments ship inside node_modules. An agent will open that and never read your post.

Since 5.8.0 the published tarball also has llms.txt, AGENTS.md, and CLAUDE.md sitting at the root. They're short pointers back to the site, named that way because that's what a lot of the tools look for by filename. The guide's section on what the npm package carries is the list. I didn't want a second copy of the docs in the tarball, going stale between releases.

I put the skills in the scaffolder too, and a CLAUDE.md that remembers the choices someone just made. CSS flavor, class prefix, icon library. Almost nobody was starting a new app with it. I did the work anyway. Field of Dreams, a little. If you build it, they will come. When an agent is the one building, those files do seem to help. When a person is, I still don't know. There haven't been many people.

The MCP server came later in the summer. Same hope, another way for an agent to ask instead of guess. What I got was about the same as the skills. Not a breakthrough. Better-looking sites, and the source finally using my components instead of a pile of custom markup. I was glad, and I was also tired.

Some of Them Started Recommending It

I kept asking. Silly prompts, the kind where you just want to see which name comes back. Eventually it started to change. It would recommend mine in some cases, mostly when the effort was high or higher, and when it searched the web.

My Cloudflare numbers started going up around then. AI bots, and some of it might be people. Hard to tell which is which. The one-shot web apps started to look better, and the agent started using my components instead of making its own.

I asked again later, plain questions this time. The wording mattered, and so did the effort setting.

This one only brought my package up when I turned the effort up:

What react library would you recommend for a new web app that uses Bulma

With effort up, Grok's first few sentences were: "For a new React app on Bulma, I'd use @allxsmith/bestax-bulma. It targets Bulma v1 and it's still being worked on. react-bulma-components is the older package people remember, and it hasn't shipped a release since 2022."

This one did better, and I didn't have to turn anything up:

What is the best react bulma library

Grok opened with: "The best React library for Bulma right now is @allxsmith/bestax-bulma. It's still maintained, and it targets Bulma v1. The other name that comes up a lot is react-bulma-components, which last published in 2022."

Claude was pickier. I have to turn the effort up to extra before it recommends bestax. Unless I do that, it feels like the model is sitting on older data, and even then it often still names react-bulma-components and lands on plain classes as the honest advice. ChatGPT and Gemini have recommended mine too. And Google, for the search "what's the best Bulma React library", has been recommending mine.

It does show up now, when the question is about Bulma. But sometimes, and really most of the time, a model still questions why someone would use mine. It recommends react-bulma-components, and then the honest recommendation is to use the plain CSS classes.

This is just what I was seeing in the chats I ran in September 2026. Ask for a web app with no other hint and it's still React, Tailwind, and shadcn/ui. Bulma only comes up when you ask for Bulma. And even then, a common answer is the 2022 package, followed by "you might be happier with the classes."

I hope the steady work wasn't wasted. It's still slow, and most days it feels slow. Training bias is real. Ask for a web app and you still get anything but Bulma, unless you force the question. There's a ton of stuff built on Bulma. It's still a tiny fraction of Tailwind, Bootstrap, and Foundation. I feel that every time I open a new chat.

I pulled the numbers so this wasn't only a feeling. Weekly downloads are npm's public counts for September 14 to 20, 2026. Stars are the GitHub counts on September 21, linked from the table. GitHub doesn't keep a separate page for a star count on a past day, so the repo is the source.

Framework	Weekly downloads	GitHub stars
Tailwind CSS	about 96 million	about 98,000
Bootstrap	about 5.1 million	about 175,000
Bulma	about 279,000	about 50,000
Foundation	about 87,000	about 30,000

Tailwind did about 96 million downloads that week. Bootstrap about 5.1 million. Bulma about 279,000. Foundation about 87,000. So Tailwind was somewhere around 340 times Bulma, and Bootstrap around 18 times. Stars are a different pile, because they add up over years. Bootstrap has about 175,000, Tailwind about 98,000, Bulma about 50,000, Foundation about 30,000. Foundation's last release on npm was September 2024. Bulma on npm is still 1.0.4, from April 2025, but the repository took fixes on September 21, 2026. I don't think people have given up on it. It's small, and that size is what I keep running into.

Why I'm Still on Bulma

I really do think Bulma is the most eloquently designed of these. I know some people will bounce off that word. Tailwind is useful, genuinely. To me it looks like an inline style that exploded into word spaghetti. Bootstrap is closer to Bulma. Older, and the conventions aren't bad, they just don't feel as considered. Bulma is wordy. I know some people don't like that. I still think it's the one I'd rather come back to in six months and be able to read.

When a model talks about those numbers, it treats them like one framework is better than the others. I don't buy that. The numbers are mostly a record of what people have written down the most.

Don't Get Discouraged

I hope the labs training these models do something about how one-note the training data is, and the bias that comes out of it. Otherwise I think the internet, and a lot of what we know how to build, converges on a single kind of answer. One CSS approach, one component library, and the rest fade out. Diversity dies. I don't want that, and I don't think it has to go that way, but it will if the training data stays this lopsided and nobody pushes the other direction.

This is me trying anyway. I'm still building, and I'm still hoping a model can name more than the one popular answer. It's a work in progress. There's a long, long way to go. If you're maintaining a package the models don't know, I hope you keep going too. The quiet is awful. Don't take it as a verdict. It doesn't happen overnight. If you keep at it, you will see it move. Slowly. Some days that is a very small comfort.

I might be inconsequential. The model might only recommend my package to the few people who ask in a particular way. Heck, it's a start.

The Future is httpyac, Not Postman AI writes .http files in seconds. Plain text, version controlled, no context switching. Postman? GUI clicks AI can’t touch. Bruno tries but httpyac’s pure text approach wins. Text-based tools dominate the AI era. 🔥

Alex Smith — Sat, 24 Jan 2026 16:50:46 +0000

AI is Killing COTS Software Hot take: AI one-shots open source problems because it trained on millions of examples. COTS? Zero training data, sparse examples, cold start every time. Your AI assistant is basically guessing. OSS + AI wins. 🤖

Alex Smith — Sat, 24 Jan 2026 16:48:02 +0000

The fastest and easiest way to setup React with Bulma and Vite.

Alex Smith — Sun, 16 Nov 2025 19:56:14 +0000

Install Bulma and React in 30 Seconds

Alex Smith ・ Nov 16

#react #bulma #vite #cli

Install Bulma and React in 30 Seconds

Alex Smith — Sun, 16 Nov 2025 04:28:52 +0000

Want to build a React app with Bulma CSS in 2025? Forget the 10-step tutorials. Skip the configuration hell. Just run one command and start coding.

One command. Under 30 seconds. You're building.

TL;DR - The Fastest Way

npm create bestax@latest my-app

Select Javascript or Typescript

Select your bulma flavor

Select your favorite Icon library

Just about done...

Wait, that's it?

Okay there is one other thing, you have to install your dependencies and start the dev server.

cd my-app
npm install
npm run dev

Start with src/App.tsx or src/App.js, and begin your journey!

That's it. You now have a production-ready React + Bulma application powered by Vite, with Javascript/TypeScript support, icon libraries, and the full power of @allxsmith/bestax-bulma at your fingertips.

Or, if you want even less interaction:

npm create bestax@latest my-app -y

The -y flag uses all the defaults and gets you up and running in literal seconds.

Want your AI agent to do it for you? Just tell Claude, ChatGPT, or your favorite coding assistant:

Use create-bestax to scaffold a new React + Bulma project

And watch it happen.

NPM

Checkout package on NPM [https://www.npmjs.com/package/create-bestax]

That was quick!

👤 Follow me @allxsmith for updates!

⭐ Feel free to star the repository if you find it helpful!

Have questions or feedback? Create an issue or start a discussion on GitHub for new ideas!

Originally published on bestax.io

Meet bestax-bulma: Modern React Components for Bulma CSS v1

Alex Smith — Sun, 09 Nov 2025 00:48:00 +0000

Hey React developers! 👋 Are you looking for a modern, actively maintained component library for Bulma CSS? Let me introduce you to bestax-bulma (pronounced "bee-stacks"), a TypeScript-first React component library that brings the full power of Bulma v1 to your React applications.

Opensource! Free as in beer🍺

Why Another Bulma React Library?

Great question! While there are other Bulma React libraries out there, many haven't been updated for Bulma v1 or are no longer actively maintained. bestax-bulma fills this gap with:

🎯 Full Bulma v1 Support: Built specifically for the latest Bulma version
📊 99% Test Coverage: Every component thoroughly tested with React Testing Library
🔷 TypeScript-First: Complete type safety with comprehensive TypeScript definitions
🚀 Modern Build: Tree-shakeable ESM and CJS builds for optimal bundle sizes
📚 Rich Documentation: Comprehensive API docs and getting started guides available at bestax.io
⚡ Active Development: Regular updates and responsive maintenance

Quick Start in 2 Minutes

Getting started is as simple as:

npm install @allxsmith/bestax-bulma bulma

Then import and use components:

import { Button, Card, Hero } from '@allxsmith/bestax-bulma';
import 'bulma/css/bulma.min.css';

function App() {
  return (
    <Hero color="primary">
      <Hero.Body>
        <Card>
          <Card.Header>
            <Card.Header.Title>Welcome to bestax-bulma!</Card.Header.Title>
          </Card.Header>
          <Card.Content>
            <p>Modern React components for Bulma CSS v1</p>
            <Button color="success">Get Started</Button>
          </Card.Content>
        </Card>
      </Hero.Body>
    </Hero>
  );
}

🚀 Try this live on StackBlitz →

Showcasing Bulma v1's New Features

🦴 Skeleton Loading States

Bulma v1 introduced the Skeleton component for beautiful loading states.

First you will see a pulsing skeleton:

Then the skeleton is replaced with the content:

import { Card } from '@allxsmith/bestax-bulma';
import { useState, useEffect } from 'react';

function LoadingCard() {
  const [isLoading, setIsLoading] = useState(true);

  useEffect(() => {
    const timer = setInterval(() => {
      setIsLoading(prev => !prev);
    }, 2000);
    return () => clearInterval(timer);
  }, []);

  return (
    <Card skeleton={isLoading}>
      <Card.Content>
        <p>Your content here!</p>
      </Card.Content>
    </Card>
  );
}

🚀 Try this live on StackBlitz →

🎨 CSS Grid Support

Take advantage of Bulma's new CSS Grid components for modern layouts:

import { Grid, Cell, Card } from '@allxsmith/bestax-bulma';

function Dashboard() {
  return (
    <Grid>
      <Cell><Card>Cell 1</Card></Cell>
      <Cell><Card>Cell 2</Card></Cell>
      <Cell><Card>Cell 3</Card></Cell>
      <Cell><Card>Cell 4</Card></Cell>
      <Cell><Card>Cell 5</Card></Cell>
      <Cell><Card>Cell 6</Card></Cell>
      <Cell><Card>Cell 7</Card></Cell>
      <Cell><Card>Cell 8</Card></Cell>
      <Cell><Card>Cell 9</Card></Cell>
    </Grid>
  );
}

🚀 Try this live on StackBlitz →

🌈 Dynamic HSL Theming

Bulma v1's HSL color system enables dynamic theming:

import { Theme, Button } from '@allxsmith/bestax-bulma';

function ThemedApp() {
  return (
    <Theme primaryH="280" primaryS="100%" primaryL="45%">
      <Button color="primary">Themed Button</Button>
    </Theme>
  );
}

🚀 Try this live on StackBlitz →

Why Developers Love bestax-bulma

1. Compound Components Pattern

We use the compound components pattern for intuitive, readable code:

import { Modal, Button } from '@allxsmith/bestax-bulma';
import { useState } from 'react';

function ModalExample() {
  const [showModal, setShowModal] = useState(false);
  const closeModal = () => setShowModal(false);

  return (
    <>
      <Button color="primary" onClick={() => setShowModal(true)}>
        Open Modal
      </Button>
      <Modal isActive={showModal}>
        <Modal.Background onClick={closeModal} />
        <Modal.Card>
          <Modal.Card.Head>
            <Modal.Card.Title>Intuitive API</Modal.Card.Title>
            <Modal.Close onClick={closeModal} />
          </Modal.Card.Head>
          <Modal.Card.Body>
            Components that make sense!
          </Modal.Card.Body>
          <Modal.Card.Foot>
            <Button color="primary" onClick={closeModal}>
              Close
            </Button>
          </Modal.Card.Foot>
        </Modal.Card>
      </Modal>
    </>
  );
}

🚀 Try this live on StackBlitz →

2. TypeScript Autocomplete Heaven

Every prop is fully typed, giving you incredible IDE support:

// Full autocomplete for colors, sizes, and more
<Button
  color="primary"  // 'primary' | 'link' | 'info' | 'success' | ...
  size="large"     // 'small' | 'normal' | 'medium' | 'large'
  isLoading
  isOutlined
/>

3. Zero Configuration

Unlike many CSS-in-JS solutions, bestax-bulma works with standard Bulma CSS. No build configuration, no CSS extraction, just import and go!

Try It Live

Want to see bestax-bulma in action? Check out bestax.io for comprehensive examples and interactive documentation. Storybook is also available for browsing individual component variations.

Comparison with Alternatives

Feature	bestax-bulma	react-bulma-components	rbx	bulma-react
Bulma v1 Support	✅	❌	❌	❌
TypeScript	✅ Built-in	⚠️ Separate	✅	❌
Test Coverage	99%	~70%	~100%	Unknown
Active Maintenance	✅ 2025	⚠️ 2021	❌ 2019	❌ 2015
Tree Shaking	✅	✅	✅	❌
Compound Components	✅	❌	✅	❌
Comprehensive Docs	✅	❌	⚠️ Partial	❌
Real CSS Grids	✅	❌	❌	❌
Configurable	✅	❌	❌	❌
Theme Support	✅	❌	❌	❌
Quick Start CLI	✅	❌	❌	❌

Get Started Today

Ready to modernize your Bulma React experience?

Install: npm install @allxsmith/bestax-bulma bulma
Explore: Check our documentation
Build: Start creating beautiful UIs with modern React patterns
Contribute: Join us on GitHub

What's Next?

This is just the beginning! In the next parts of this series, we'll dive deep into:

Part 2: Building Beautiful UIs with Bestax Components
Part 3: Forms, Data Display, and Advanced Patterns

👤 Follow me @allxsmith for updates!

⭐ Feel free to star the repository if you find it helpful!

Have questions or feedback? Create an issue or start a discussion on GitHub for new ideas!

Originally published on bestax.io