Comparing Semantic UI and Bulma
Tags: semanticui, bulma, css, html
Published: 2023-02-22 00:27:47

by [Lawrence Franklin Chukwudalu](https://blog.openreplay.com/authors/lawrence-franklin-chukwudalu)

Front-end developers are always searching for new tools and frameworks to help them build faster and better websites. CSS frameworks make it even easier by taking away the hassle of designing the layout for their applications, letting them focus on the core functionalities.

This post will compare two CSS frameworks, Bulma and Semantic UI, for building responsive and beautiful user interfaces. In this article, we'll compare these two CSS libraries based on their ease of use, performance, pros and cons, etc. At the end of this article, you will learn which frameworks best suit your project and in what cases Bulma should be used over Semantic UI and vice versa.

## What is Semantic UI

[Semantic UI](https://semantic-ui.com/) is a free and open-source UI (user interface) library, just like Bootstrap, with built-in components like buttons, layouts, etc., for building appealing websites. It is powered by the [LESS CSS](https://lesscss.org/) compiler and [jquery](https://jquery.com/). It enables developers to create nice-looking, lightweight, and responsive applications. It is often called a `copy-and-paste` framework.

### Installation

The easiest way to install SemanticUI is via NPM. Its NPM package has unique install scripts that make setup intuitive and update seamlessly. 

According to [documentation](https://semantic-ui.com/introduction/getting-started.html):

> SemanticUI uses [Gulp](http://www.gulpjs.com/) to provide command-line tools for building themed versions of the library with just the components you need.

This means that we'll need to install Gulp. It is important to note that Gulp is an NPM module and must be installed globally like so:
```
    npm install -g gulp
```
Then we can now install SemanticUI using NPM like so:
```
    npm install semantic-ui --save
    cd semantic/
    gulp build
```
You can alternatively add SemanticUI as a CDN to your HTML like so:
```htmlembedded
<link rel="stylesheet" type="text/css" href="semantic/dist/semantic.min.css">
<script
    src="https://code.jquery.com/jquery-3.1.1.min.js"
    integrity="sha256-hVVnYaiADRTO2PzUGmuLJr8BLUSjGIZsDYGmIJLv2b8="
    crossorigin= "anonymous">
</script>
<script src="semantic/dist/semantic.min.js"></script>
```
## What is Bulma

[Bulma](https://bulma.io/) is an open-source CSS framework with ready-to-use components for building responsive user interfaces with no required CSS knowledge. Bulma is built on Flexbox, a CSS layout model that adjusts a page element's width based on its container's width.
Released in 2016, Bulma has gained popularity among front-end developers so much that it compares to other popular CSS frameworks like Bootstrap.

### Installation

Bulma allows you to either use the pre-compiled CSS file or install the SASS files to tailor the styles to your specific needs.
Bulma is available as a package on npm, the package manager for JavaScript. It is also available as a package on Yarn. Bulma can be installed using npm or Yarn like so:

    # using npm
    npm install bulma
    
    # using yarn
    yarn add bulma

Alternatively, you can add Bulma as a CDN in your HTML,
```htmlembedded
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bulma@0.9.4/css/bulma.min.css">Conclusion
```
There're a few other ways to install Bulma. To learn more, you should check out their [documentation](https://bulma.io/documentation/overview/start/).

## Why Semantic UI

Semantic UI is incredible, specifically for building small projects with unique designs. Although there're multiple advantages to using the framework, it still has some drawbacks. Below are some of its advantages and disadvantages.

### Pros
- It offers a variety of themes that you can choose from.
- Semantic UI lets you choose different elements from different themes. For example, you can have a form from one theme and a button from another.
- Semantic UI is based on natural language principles, making it completely intuitive. To get three buttons or dropdown, you can write classes like "three buttons" or "dropdown" to get three buttons or dropdown, respectively.
### Cons of Semantic UI
- Semantic UI has less browser compatibility. For example, it doesn't support Internet Explorer 7.
- Semantic UI is not actively developed and updated. Back in 2018, it caused [some worry](https://github.com/Semantic-Org/Semantic-UI/issues/6109) for some of Its users as the development of Semantic UI almost seems to be neglected.
## Why Bulma

Since Bulma is built on flexbox, it makes tasks like creating grids super easy. There're a lot of advantages to using Bulma, notably:

### Pros of Bulma
- Bulma is frequently updated with new features, making it relevant to the latest development trends.
- Bulma is modular, meaning you can use only the pieces you need and omit the rest.
- Bulma is highly responsive
### Cons of Bulma
- Since Bulma is CSS only, adding a feature in Bulma that requires JavaScript, such as toggle, will require you to write a custom script.
- Bulma runs very slow on the Internet Explorer web browser
## Creating simple components with both libraries

Well, it will never be a complete article without seeing a sample code snippet of Semantic UI and Bulma. In this section, we will create a simple button and a card component with both libraries to familiarize you with the syntax. We'll create these elements inside a simple React component.

Note: Semantic UI and Bulma offer third-party libraries such as `semantic-ui-react` and `react-bulma-components` that provide React components for Semantic UI and Bulma, respectively, to simplify integration, these CSS libraries can be used with any front-end framework and even plain HTML.

### Semantic UI button with React
To use Semantic UI in your React project, you'll need to install the `semantic-ui-react` and `semantic-ui-css` libraries by running "npm install semantic-ui-react semantic-ui-css "in your project's directory. Then you'll import the Semantic UI CSS file in your app's entry file (the index.js file) using `import 'semantic-ui-css/semantic.min.css';`. 
You can now use the components provided by the `semantic-ui-react` library in your React components, just like any other React component.
Here is an example of creating a simple button using Semantic UI with React:
```javascript
import React from 'react';
    
function MyButton() {
    return (
        <div className='app'>
          <button className="ui blue button">This is a blue button</button>
          <button className="ui black button">This is a black button</button>
        </div>
    );
}
    
export default MyButton;
```

In this example, we import the `Button` component from the `semantic-ui-react` package and use it to create a simple button with a "Click me" label. The `className` properties, `"ui blue button``` and `"ui black button``` are used to apply the primary colors Blue and Red to the buttons, respectively.
And you can use it in your JSX like so:
```html
    <MyButton />
```
If you followed this correctly, you should have two buttons like so:

![1](https://blog.openreplay.com/images/comparing-semantic-ui-and-bulma/images/image01.png)


To learn more about the different props and features of the `Button` component and other components that Semantic UI offers, you should check the [Semantic UI React documentation](https://react.semantic-ui.com/elements/button/).

### Bulma button with React

Similarly to Semantic UI, to use Bulma in your React app, you must first install the Bulma CSS framework by running `npm install bulma` in your project's directory. Then import the Bulma CSS file in your app's entry file (the index.js file) using `import 'bulma/css/bulma.css';`.
You can apply the class names Bulma provided in your HTML elements to apply its styles.
Here is an example of a simple button component using Bulma for React:
```javascript
import React from 'react';
    
const MyButton = () => {
    return (
        <div className='app'>
          <button className=" button is-primary">
            This is a primary button
          </button>
          <button class=" button is-danger">
            This is a warning button
          </button>
        </div>
    )
}
    
export default MyButton;
```
We use the `button` HTML tag in this example and apply the ```is-primary`" and ```is-dangerous`" classes. The Bulma framework provides the ```is-primary`" class to give the button the primary styling with a green background and the "is-danger" class to give the button a red background.
Here's the result of the above code snippet:

![2](https://blog.openreplay.com/images/comparing-semantic-ui-and-bulma/images/image02.png)


You can find more information about the different classes and features of the button component and other components that Bulma offers in the [Bulma CSS documentation](/paper/ep/redirect/external-link?url=https%3A%2F%2Fbulma.io%2Fdocumentation%2Felements%2Fbutton%2F&hmac=ZXPblDJjcI1MZKBzNPVZQ4B2kjzu4wNT145IR%2BFMO34%3D).
Bulma and Semantic UI offer many robust components, such as buttons, cards, accordions, and dropdowns, providing outstanding styling options for your projects.


<h2>Session Replay for Developers</h2> 
<p><em>
Uncover frustrations, understand bugs and fix slowdowns like never before with <strong><a href="https://github.com/openreplay/openreplay" target="_blank">OpenReplay</a></strong> — an open-source session replay suite for developers. It can be <strong>self-hosted</strong> in minutes, giving you complete control over your customer data
</em></p>
<img alt="OpenReplay" width="768" height="400" src="https://blog.openreplay.com/assets/overview_Z17Qdyg.png" class="astro-UXNKDZ4E" loading="lazy" decoding="async">
<em>Happy debugging! <a href="https://openreplay.com" target="_blank">Try using OpenReplay today.</a></em>






## Creating a simple card

Creating a card is a common task in web development and can be done using various CSS libraries. Using Bulma and Semantic, you can compare the process of creating a card and the resulting design. This can help you understand each library's strengths and weaknesses and decide which is best suited for your project.

### Simple card with Semantic UI

Let's create a simple card with Semantic UI and React
```javascript
import React from "react";
export default function App() {
    return (
        <div className="App">
          <div className="ui cards">
            <div className="card">
              <div className="content">
                <div className="header">A Semantic UI card</div>
                <div className="description">
                  Elliot Fu is a film-maker from New York.
                </div>
                <span>31st January 2023</span>
              </div>
              <div className="ui  segment">
                <button className="ui positive button">Save</button>
                <div className="ui negative button" tabindex="0">
                  Delete
                </div>
              </div>
            </div>
          </div>
        </div>
      );
    }
```
Within the App component, we created a card element with the class `ui card`, which creates a card container. Inside the card `div`, we created another `div` element with a class name of `card` that creates the card itself.

The card has a header and description, created with the `header` and `description` classes, respectively. 

Lastly, we created an additional segment to the card with the `ui segment`, which contains two buttons, a save button, and a delete button, created with the `save` and `delete` classes, respectively.

Overall, the code defines a Semantic UI card with a header, description, and buttons to save or delete the card contents.


![3](https://blog.openreplay.com/images/comparing-semantic-ui-and-bulma/images/image03.png)


### Simple card with Bulma
Let's create a simple card component with Bulma and React.
```javascript
import React from "react";
export default function App() {
    return (
        <div className="App">
          <div className="card has-background-primary-light">
            <header className="card-header ">
              <p className="card-header-title is-centered">A Bulma card</p>
              <button className="card-header-icon" aria-label="more options">
                <span class="icon">
                  <i class="fas fa-angle-down" aria-hidden="true"></i>
                </span>
              </button>
            </header>
            <div class="card-content">
              <div class="content">
                This is a simple card built with Bulma and React as an Open Relay
                article exmple.
                <br />
                <time datetime="2016-1-1">31st, Jan 2023</time>
              </div>
            </div>
            <footer className="card-footer">
              <p href="#" className="card-footer-item has-text-primary">
                Save
              </p>
              <p href="#" className="card-footer-item has-text-danger">
                Delete
              </p>
            </footer>
          </div>
        </div>
    );
}
```
Within the "App" div, we created a div with a class of `card has-background-primary-light`, which creates a card component with a light blue background color.
The header of the card is created using the "card-header" class provided by Bulma and contains the title "A Bulma card" with a class of "card-header-title is-centered". The `is-centered` class places the title centered on the card.
The body of the card is created using the `card-content` class and contains some random text and a date.
The footer of the card is created using the `card-footer` class and contains two buttons, one with a class of `card-footer-item has-text-primary`, which saves the content, and another with a class of `card-footer-item has-text-danger`, which deletes the content.

Overall, this component displays a sample card with a light blue background, a header with a centered title, a body with some text and a date, and a footer with two buttons.

![4](https://blog.openreplay.com/images/comparing-semantic-ui-and-bulma/images/image04.png)

## Key differences

Both Semantic UI and Bulma come with unique features that meet different requirements. It will be cumbersome to compare them feature by feature. For this reason, we'll only compare them based on popularity, ease of use, and performance.

### Popularity

There are no statistics to tell if Bulma is more popular than Semantic UI or vice versa. However, one way to tell is based on their forks and stars on GitHub.
Bulma has 3.1k forks and 46.5k stars on GitHub, while Semantic UI has 5.1k forks and 50.3k stars on GitHub. With these GitHub interactions, we can assume that Semantic UI is more popular than Bulma.

### Ease of use

Bulma's [documentation](https://bulma.io/documentation/overview/) is extremely intuitive as it gives elements with examples, code examples, and a detailed explanation for every component. Also, Bulma's website includes [starter templates](https://bulma.io/documentation/overview/start/) and [interactive tutorials](https://bulma.io/videos/) to get you started in no time.
Semantic UI has great documentation as well. Also, Semantic UI is very intuitive. As mentioned earlier, its classes are named in readable formats like "three buttons," "two columns," etc., meaning you could easily write out these classes by intuition.

### Performance

Among the CSS libraries available, Semantic UI has one of the largest file sizes at 730 KB uncompressed, and 95 KB gzipped.
Unlike Semantic UI, Bulma is CSS only, meaning it doesn't include inbuilt JavaScript.
Bulma is 25kb, and considering you don't have to pull in JavaScript; it is more lightweight than Semantic UI.
If speed is part of the factors you consider for choosing a framework, then Bulma is the right tool. Firstly, because of its size and its modularity, it lets you remove the part(components) you don't need.

## Semantic UI or Bulma: Which is better?

As the case has always been in comparing two similar tools, choosing a CSS framework over another highly depends on your project. 
Based on the aforementioned points, the debate is now relatively easy; Semantic UI for projects with custom designs, especially if you're not concerned with speed, and Bulma, if customization is not a key factor for your project and speed, is.

## Conclusion

Designing the user interface of your websites shouldn't be as difficult as programming the functionalities. CSS frameworks make this possible by providing you with prebuilt components like buttons, layout, nav bars, etc., with which you can quickly build amazing user interfaces for your web apps.
This post compared two powerful CSS frameworks, Bulma and Semantic UI, for building beautiful, eye-catching web apps. We compared them based on their performance, ease of use, and popularity. Ultimately, choosing which best fits your project's demand is up to you.





[![newsletter](https://blog.openreplay.com/newsletter_Z1P0UIP.png)](https://newsletter.openreplay.com/)