Sass Tutorial

Sass (Syntactically Awesome Style Sheets) is a preprocessor that sits on top of CSS. It adds features and functionalities that make writing and maintaining CSS stylesheets easier and more scalable. You write Sass code (often in SCSS, similar to CSS), and a tool compiles it into regular browser-friendly CSS. With Sass, you write cleaner, more efficient CSS with superpowers!

  • Variables: Define reusable values like colors, fonts, and sizes using variables. This makes your stylesheets more consistent and easier to update globally.
  • Nesting: Organize your styles hierarchically by nesting selectors within each other, creating a more readable and maintainable code structure.
  • Mixins: Create reusable code blocks containing styles you can apply to multiple elements throughout your project. This promotes code reuse and reduces redundancy.
  • Partials: Break down your stylesheets into smaller, reusable files for better organization and maintainability.
  • Functions: Perform calculations and manipulations within your stylesheets, allowing for more dynamic and flexible styling.
  • Loops: Sass loops, like @each and @for, let you automate repetitive tasks, reducing code duplication and making your stylesheets more maintainable..

Sass code (often written in SCSS, similar to CSS) needs to be compiled into regular CSS for browsers. Here are some popular methods:

  1. VS Code Live Sass Compiler: This built-in extension for VS Code offers real-time compilation, ideal for quick development and seeing your style changes instantly.
  2. Command-Line Tools:
    • Ruby Sass: The original compiler, requiring Ruby installation.
    • LibSass: A high-performance alternative written in C++.
  3. Build Tools (Gulp & Grunt): Popular task runners that integrate Sass compilation into your build process for streamlined workflows.
  4. NPM: Node Package Manager allows installing various Sass compilers like sass or dart-sass for command-line use.
  5. Online Compilers: For quick experimentation without local setup, online tools can compile your Sass code.

Sass variables act like nicknames for styles. You give a value a name with a $ symbol, then use that name throughout your code to keep things consistent and easier to update.


// Define variables
$primary-color: #007bff; // Blue
$secondary-color: #ffc107; // Orange
$font-family: "Open Sans", sans-serif;

// Use variables in styles
body {
  background-color: $primary-color;
  font-family: $font-family;

.heading {
  color: $secondary-color;
  font-size: 1.8rem; // Example using rem unit

In this example:

  • We define three variables: $primary-color, $secondary-color, and $font-family.
  • We use the $ symbol to denote them as variables.
  • Later in the code, we use these variables in place of their actual values for properties like background-color and font-family.

Sass nesting lets you indent selectors within other selectors, mimicking the structure of your HTML. This creates a cleaner, more organized way to define styles for child elements without repeating the parent selector each time.


nav {
  background-color: #eee;
  padding: 1rem;

  ul { // Nest the unordered list (ul) selector within the nav selector
    margin: 0;
    padding: 0;
    list-style: none;

    li { // Nest the list item (li) selector within the ul selector
      display: inline-block;
      margin-right: 1rem;

      a { // Nest the anchor tag (a) selector within the li selector
        color: #333;
        text-decoration: none;
        padding: 0.5rem 1rem;

        &:hover { // Nest a pseudo-class selector within the a selector
          color: #007bff;
      } /* end a */
    } /* end li */
  } /* end ul */
} /* end nav */

This example shows how each element (nav, ul, li, a) is nested within its parent element using indentation. This way, you can easily define styles specific to child elements without needing to repeat the nav selector for each nested element.

In Sass, a mixin is a reusable block of CSS declarations that you can include in your stylesheet using the @include directive. It’s essentially a way to write styles once and use them multiple times throughout your project, promoting DRY (Don’t Repeat Yourself) principles. You use the @mixin at-rule followed by the mixin name and optional arguments within parentheses. Here’s the basic syntax:


@mixin <mixin-name>(<arguments...>) {
  /* CSS declarations */
  • <mixin-name>: This is the name you’ll use to refer to the mixin later.
  • <arguments...> (Optional): These are placeholders for values you can pass when using the mixin.

This mixin defines styles for a button, taking two arguments: $color and $background for customization:


@mixin button-styles($color, $background) {
  padding: 10px 20px;
  border: 1px solid #ccc;
  color: $color;
  background-color: $background;

You include a mixin in your stylesheet using the @include directive followed by the mixin name and any arguments you want to pass. Here’s the syntax:


.primary-button {
  @include button-styles(#fff, #007bff);

.secondary-button {
  @include button-styles(#333, #fff);

Here, we use the button-styles mixin twice, passing different arguments to create primary and secondary button variations.

Sass partials are reusable chunks of Sass code stored in separate files. They typically start with an underscore (_) before the filename, like _buttons.scss. These files are not compiled into CSS directly.

1. Create a partial file:

Create a file named _buttons.scss and add the following content:


// Define styles for buttons in the partial
.button {
  padding: 0.5rem 1rem;
  border: none;
  border-radius: 4px;
  cursor: pointer;
  transition: background-color 0.2s ease;

.primary-button {
  @extend .button; // Extend base button styles
  background-color: $primary-color;
  color: #fff;

.secondary-button {
  @extend .button; // Extend base button styles
  background-color: $secondary-color;
  color: #333;

This partial defines base styles for buttons in the .button class and then creates two variations (.primary-button and .secondary-button) using the @extend directive to inherit styles from the base class.

2. Import the partial in your main Sass file:

In your main Sass file (e.g., styles.scss), add the following line:


@use "buttons"; // Import the buttons partial

This line tells Sass to import the styles defined in the _buttons.scss file.

3. Use the button classes in your HTML:

Now you can use the .primary-button and .secondary-button classes in your HTML to style your buttons:


<button class="primary-button">Primary Button</button>
<button class="secondary-button">Secondary Button</button>

This example demonstrates how Sass partials promote code organization and reuse. You define styles once in the partial and then import them wherever needed, keeping your main Sass file clean and focused.

Sass functions allow you to define reusable blocks of code that perform specific tasks on SassScript values. They are a powerful tool for promoting code clarity, reducing redundancy, and making complex calculations or manipulations easier to manage.

Here’s a simple example of a Sass function to lighten a color:


// Define a function named lighten
@function lighten($color, $amount: 10%) {
  // Use built-in sass:color module function
  return lighten($color, $amount);

// Example usage: lighten a blue color by 20%
$light-blue: lighten(#007bff, 20%);

// Use the lightened color in your styles
body {
  background-color: $light-blue;

This example shows the following aspects of Sass functions:

  • Defining the function: We use the @function directive followed by the function name (lighten) and optional arguments ($color and $amount).
  • Function body: The function utilizes the built-in lighten function from the sass:color module to lighten the provided color by a specified amount (defaulting to 10%).
  • Using the function: We call the lighten function with a specific color value and an optional amount to create a new, lighter color stored in the $light-blue variable.
  • Applying the result: Finally, we use the lightened color ($light-blue) in our styles for the body element.

This approach allows you to easily lighten any color throughout your stylesheet by simply calling the lighten function and providing the desired color and amount. It improves readability and maintainability compared to repeatedly using calculations directly within your styles.

Sass loops (@each & @for) automate repetitive styling tasks by iterating through lists or maps, reducing code duplication and improving maintainability.

Using @each loop:

Imagine you have a list of colors you want to use for backgrounds of different sections in your website.


$section-colors: (
  "header": #f0f0f0,
  "main": #fff,
  "footer": #eee

@each $section, $color in $section-colors {
  .#{$section} { // Use interpolation for selector
    background-color: $color;

This example uses the @each loop to iterate through a map named $section-colors. The loop:

  1. Defines a map associating section names (header, main, footer) with their corresponding background colors.
  2. Iterates through each key-value pair in the map.
  3. Uses variables $section and $color to hold the current section name and background color during each iteration.
  4. Employs string interpolation (#{$section}) to dynamically create the selector for each section (e.g., .header, .main, .footer).
  5. Sets the background-color property for each section based on the value stored in $color.

Using @for loop:

Let’s say you want to create a grid layout with a fixed number of columns (3 in this case).


@for $i from 1 through 3 { // Loop from 1 to 3 (inclusive)
  .column-#{$i} {
    width: 33%; // Each column takes 33% width
    float: left;
    padding: 1rem;

This example utilizes the @for loop to define styles for a specific number of columns:

  1. Defines a loop iterating from $i = 1 to $i = 3 (inclusive).
  2. Inside the loop, $i holds the current iteration number.
  3. Uses string interpolation (#{$i}) to construct class names for each column (e.g., .column-1, .column-2, .column-3).
  4. Sets styles for each column, including width, float behavior, and padding.

Sass is a fantastic tool for writing cleaner, more maintainable, and powerful CSS. It offers features like variables, mixins, nesting, and loops that help you keep your styles organized and efficient. For a deeper dive into everything Sass has to offer, check out the comprehensive Sass documentation! Happy styling!