React Sass Styling

Sass helps you write cleaner, more maintainable, scalable CSS for your React components. Leverage features like variables, mixins, and nesting to streamline your styling process and create a more organized codebase. Sass makes styling React applications a breeze, allowing you to focus on building exceptional user interfaces.

Table of Contents

React Styling with Sass

While plain CSS remains the foundation for web styling, Sass (Syntactically Awesome Style Sheets) offers a powerful and elegant alternative for React projects. Sass is a perfect match for building React applications:

Enhanced Preprocessing Power: Sass goes beyond writing basic CSS styles. It is a preprocessor, allowing you to use variables, mixins, and nesting. This translates to cleaner, more maintainable code.

  • Variables
    Imagine setting a consistent primary color for your application in one place rather than repeating the hex code across multiple stylesheets. Sass lets you define variables for colors, fonts, and other stylistic properties, making updates a breeze.
  • Mixins
    Think of reusable style blocks. Sass lets you create mixins that combine common styles and apply them to different components, reducing code duplication and promoting consistency.
  • Nesting
    Organize your styles hierarchically. Sass allows you to nest styles within each other, mimicking the structure of your React components for better readability and easier maintenance.

Seamless Integration with React: Integrating Sass with React is straightforward. Sass compiles down to regular CSS, which React understands perfectly. You can import your Sass files directly into your React components, creating a smooth development workflow where your styles stay closely tied to your components.

What is Sass?

Sass (Syntactically Awesome Style Sheets) is a special tool for web developers that adds superpowers to regular CSS. It lets you organize and write less CSS code by using handy features like variables (to store colors or sizes), mixins (like reusable style blocks), and nesting (to mirror the structure of your website). Think of it like this: you write your styles in Sass, and a special program compiles it into the regular CSS that your web browser understands. This makes your styles easier to create, update, and keep looking sharp!

Sass Syntax Basics: Nesting, Variables, and Mixins

Sass offers a handful of powerful features that make styling React components a breeze. Here’s a quick introduction to three key concepts:


Nesting allows you to organize your styles hierarchically, mimicking the structure of your React components. Child selectors are indented within their parent selector, creating a clear visual representation of style inheritance.


  /* styles.scss */
  .container {
      background-color: #f0f0f0;
      padding: 1rem;

      .heading {
          font-size: 1.5rem;
          margin-bottom: 0.5rem;


  • Line 2: We define a class named container.
  • Line 3: The container class has a background color set.
  • Line 4: Padding is added to the container.
  • Line 6: Nested within the container class, we define a class named heading.
  • Line 7: The heading class defines a font size.
  • Line 8: A margin is added to the bottom of the heading.

Nesting helps visualize how styles are applied within your component hierarchy.


Variables act like placeholders for values you can reuse throughout your Sass code. This promotes consistency and simplifies updates. Imagine defining a variable for your primary brand color and using it wherever needed instead of repeating the hex code.


Mixins are reusable blocks of styles. They allow you to group common styles and apply them to different components, reducing code duplication and promoting a clean, modular approach.

Project Setup

Before we dive into the exciting world of Sass for styling your React components, it’s essential to get your project ready! This involves ensuring you have Node.js and npm (or yarn) installed, which are the building blocks for working with Sass. Then, if you don’t already have one, we’ll use tools like create-react-app to set up the foundation of your React project. Once these pieces are in place, we can install the Sass preprocessor and start styling!


To use Sass for styling your React projects, you’ll need a few things in place:

1. Node.js and npm (or yarn)

To function, Sass relies on Node.js and its package manager (npm or yarn). These tools will be used to install and manage Sass and any additional dependencies your project might require. You can download and install Node.js from the official website ( Here’s a quick way to check if you have Node.js and npm installed by opening your terminal and running:

node -v  # Check Node.js version
npm -v  # Check npm version

2. Basic React Project Understanding

While a deep understanding of React isn’t strictly necessary, a foundational grasp of React concepts like components and JSX will make integrating Sass within your React project structure easier.


  • Line 1: This line runs the node -v command to check the installed Node.js version on your system.
  • Line 2: This line runs the npm -v command to check the installed npm version on your system.

Having Node.js and npm (or yarn) set up allows us to install Sass and any related tools needed for styling React components with Sass.

Creating a New React App (Using create-react-app)

If you’re starting fresh with your React project and aiming to use Sass for styling, a great way to kick things off is by utilizing create-react-app. Here’s how to create a new React project:

npx create-react-app my-sass-project


  • Line 1: This line uses npx to execute the create-react-app command. npx comes bundled with npm (version 5.2+) and allows running packages from the npm registry without installing them globally.
  • my-sass-project: Replace this with your preferred project name.

The create-react-app tool will create a new React project with a basic structure and pre-configured dependencies. This provides a solid foundation for integrating Sass in the next steps.

Installing Sass with npm or yarn

Now that your React project is set up, let’s install Sass to use its styling power! We’ll explore how to do this using either npm or yarn, the most common package managers for Node.js projects.

Using npm

cd my-react-app  # Replace 'my-react-app' with your actual name
npm install sass --save-dev


  • Line 1: This line uses the cd command to change directories. Navigate into your React project directory (replace my-react-app with your project name).
  • Line 2: This line executes the npm install command to install a package. We specify sass as the package to install and the --save-dev flag to include in your project’s development dependencies. This means Sass won’t be bundled with your final production build.

Using yarn

cd my-react-app  # Replace 'my-react-app' with your actual name
yarn add sass -D


  • Line 1: Similar to npm, navigate into your project directory using cd.
  • Line 2: This line uses the yarn add command to install a package. We specify sass as the package and the -D flag (equivalent to npm’s --save-dev) to mark it as a development dependency.

Once you run either of these commands, Sass will be downloaded and installed within your project.

Styling Your First React Component with Sass

Adding Sass power to your first React component is a great leap forward in your styling journey! Think of it like this: you’ll start with a regular CSS file, then rename it to a “.scss” or “.sass” extension. This little change unlocks the potential to write more organized and efficient styles for your React component using Sass features like variables, nesting, and mixins. Sass adds structure and reusability to your styling process, making your React components look sharper and easier to maintain.

Renaming Your CSS Files

Now that Sass is installed let’s prepare your React project to use it. The first step is to rename your existing CSS files. Sass can handle two main syntax options: .scss and .sass. Choose the one you prefer for your project (they compile to the same CSS).

Renaming Example (Assuming Existing CSS File)

/* Before (assuming a file named styles.css) */
/* styles.css */

/* After (renaming to .scss) */
/* styles.scss */


  • Lines 1-2: This section represents the initial state, where you might have a CSS file named styles.css.
  • Line 4: Here, we’ve renamed the file to styles.scss, indicating that it will contain Sass code.

Simply changing the file extension from .css to .scss (or .sass), you signal to the Sass compiler that these files contain Sass code and must be processed before your React application is used.

Creating Your First Sass File

Let’s create a basic Sass file to show its capabilities. We’ll explore variables for color consistency and nesting to mimic your component structure.

Create a New File Named styles.scss in Your React Project’s src Folder.


 /* styles.scss */

 /* Define a variable for primary color */
 $primary-color: #333;

 /* Style for a container element */
 .container {
     background-color: $primary-color;
     padding: 1rem;

     /* Nested styles for heading element within container */
     .heading {
         font-size: 1.5rem;
         color: #fff;


  • Lines 1: This line specifies the filename (styles.scss) within your src folder.
  • Line 4: We define a variable named $primary-color and assign it a hex code value for your primary color.
  • Line 7: We define a class named container.
  • Line 8: The background-color property of the container class is set using the $primary-color variable. This demonstrates how variables promote consistency.
  • Line 12: Nested within the .container class, we define a class named .heading.
  • Line 13: The font size for the .heading class is set.
  • Line 14: The color of the .heading class is set to white (#fff).

Importing Sass into Your React Components

Now that you have a styles.scss file containing your Sass code, it’s time to connect it to your React components. Here’s how to import the Sass file:

Importing Sass in a React Component

import React from 'react';
import './styles.scss';  // Import your Sass file

function MyComponent() {

    return (
        <div className="container">
            <h1 className="heading">This is my component!</h1>

export default MyComponent;


  • Lines 1-2: We import React and your Sass file, styles.scss. The relative path ./styles.scss indicates the file is in the same directory as your React component.
  • Lines 4-11: This defines a functional React component named MyComponent.
  • Line 6: Within the JSX return statement, we use the className attribute to apply the styles defined in your Sass file. Here, we use the classes .container and .heading.
  • Lines 13: We export the MyComponent for other parts of your application.

By importing the Sass file, you make the styles defined within it available to your React component. Now, when you render the MyComponent, the styles from styles.scss will be applied to the corresponding classes in your JSX.

Organizing Your Sass

As your React project grows, maintaining a well-structured Sass codebase becomes crucial. Here’s a glimpse into some best practices for organizing your Sass files:

Folder Structure Example

   |-- components/  # Folder for component-specific styles
   |   |-- Button/
   |   |   |-- Button.scss
   |   |-- Card/
   |   |   |-- Card.scss
   |   |-- ... (other component folders)
   |-- layouts/  # Folder for layout-specific styles
   |   |-- Header.scss
   |   |-- Footer.scss
   |   |-- ... (other layout folders)
   |-- base/  # Folder for global styles and resets
   |   |-- _reset.scss  # Common CSS resets
   |   |-- _variables.scss  # Global variables
   |   |-- _mixins.scss  # Reusable mixins
   |-- styles.scss  # Main Sass entry point (optional)
   |-- ... (other project files)


  • Lines 1-17: This represents a sample folder structure for your Sass files within the src directory of your React project.
  • Lines 2-7: A components folder houses Sass files specific to individual React components. Each component can have its own Sass file (e.g., Button.scss, Card.scss).
  • Lines 8-11: A layouts folder stores Sass files for your application’s layouts, such as Header.scss and Footer.scss.
  • Lines 12-15: A base folder contains foundational styles like common CSS resets (_reset.scss), global variables (_variables.scss), and reusable mixins (_mixins.scss).
  • Line 16: An optional styles.scss file can act as your main Sass entry point, where you import all your other Sass files for compilation.

This organized structure promotes maintainability and scalability. Specific styles are grouped logically, making it easier to find and update them. Global styles and reusable elements are kept separate, preventing conflicts.

Common Sass File Patterns

As your React project grows, maintaining a well-organized Sass codebase becomes essential. Here’s an overview of a popular Sass file pattern, the 7-1 Pattern, and a variation:

The 7-1 Pattern

This pattern suggests dividing your Sass project into two main directories:

  1. Base (7 parts): Houses foundational styles like resets, variables, mixins, and base styles (typography, buttons, etc.). These styles are typically spread across multiple Sass files for better organization.
  2. Components (1 part): Contains Sass files specific to your React components.

Example Folder Structure

   |-- base/
   |   |-- _variables.scss
   |   |-- _mixins.scss
   |   |-- _reset.scss
   |   |-- buttons.scss
   |   |-- typography.scss
   |   |-- ... (other base styles)
   |-- components/
   |   |-- Button/
   |   |   |-- Button.scss
   |   |-- Card/
   |   |   |-- Card.scss
   |   |-- ... (other component folders)
   |-- styles.scss  # Optional entry point (imports base and components)


  • Lines 2-8: The base directory holds Sass files for foundational styles.
  • Lines 3-6: Files like _variables.scss, _mixins.scss, and _reset.scss are common within the base directory.
  • Lines 9-14: The components directory stores Sass files specific to your React components.

Variation: BEM Style Naming

BEM (Block-Element-Modifier) is a popular naming convention for CSS classes. You can integrate it with the 7-1 pattern for more specific and reusable styles:

/* base/buttons.scss */
.button {
    /* Base styles for all buttons */

.button--primary {
    /* Modifier for primary button */

/* components/Button/Button.scss */
@import '../base/buttons';

/* Import base styles */
.my-button {
    /* Block-level styles for this component's button */

.my-button--warning {
    /* Modifier for this component's button */


  • Lines 2-5: The base/buttons.scss file defines base styles for buttons.
  • Lines 13-19: A modifier class, .button--primary, is created for specific button variations.
  • Line 13 (Button.scss): Imports the base styles from buttons.scss.
  • Lines 16-19: The Button.scss file defines component-specific styles for the button.
  • Lines 21-24: A component-specific modifier class, .my-button--warning, is created.

Integrating Sass into Your React Project with the Node Sass Module

Here’s a step-by-step guide on how to add Sass to a React project for styling with enhanced features:

Step 1: Create React App

If you don’t have one already, use create-react-app to set up a new project:

npx create-react-app my-sass-app

Step 2: Install Node SASS Package

Navigate into the project directory and install the node-sass package:

cd my-sass-app 
npm install node-sass --save-dev

Step 3: Write SASS in CSS File

Create a new Sass file (e.g., styles.scss ) in your src directory:

.my-element {
    color: #333;

    &:hover {
        background-color: lighten(#333, 10%);

Step 4: Create Component File

Create a new React component (e.g., MyComponent.js):

import React from 'react';
import './styles.scss';

function MyComponent() {

    return (
        <div className="my-element">
            Hello from React with Sass!

export default MyComponent;

Step 5: Update App Js File

Import your component into your main App.js file:

import React from 'react';
import MyComponent from './MyComponent';

function App() {

    return (
            <MyComponent />

export default App;

Step 6: View App in Browser

Start your development server:

npm start

Open your browser (usually at http://localhost:3000/) to view your React component styled with Sass!