The New SASS Module System: Out with
@import, In with @use
In October of 2019 Sass announced their new module system, which primarily addressed the switch from using
@use instead. Let’s dive into what this means and how you should be using this new way to structure your SCSS files.
Note: The new Sass modules and what is outlined below is only compatible with Dart Sass 1.23.0. If you are using LibSass as your Sass engine (ex. VS Code CompileSass uses LibSass) you may have to wait a while longer.
What is @use
@use rule is the replacement for
@import which allows other stylesheets to use its variables, functions, and mixins.
What makes the
@use import different is that the module (file imported using
@use) is only imported once, no matter how many times you reference it in your project.
Tip: You’ll see references to what Sass calls “members” — these include the variables, functions and mixins within stylesheets.
How to Use @use
General File Import
The syntax to import a file is almost identical as to what we were already used to with the
The new modular system does not make all variables available globally. Furthermore, it creates what is called namespaces for each partial / module, which is the file name by default.
This means that you have to append the variable name with its namespace name when referencing it in your stylesheet. This helps with naming conflicts in the event you have the same variable name across multiple files, such as
Changing the Namespace (Reference)
If typing out partial stylesheet names seems like too much of an effort, you can modify the name reference as follows:
@use ‘constants.scss` as c; to change the namespace reference.
@use ‘constants.scss’ as *; to not have to reference a namespace.
Tip: You can also explore using the
@forwardrule which does not add any namespaces to names. This is primarily intended for library authors who want to expose only certain parts of their systems or when you want to group several individual pieces into one *namespace*. Read more about it below.
Members that begin with — (hyphen) or _ (underscore) are private to the current stylesheet that was imported using the
For example, you can reference a private color variable named
$_primaryRed in your
_buttons.scss partial which will only be accessible in that file, and not globally, say in a
_footer.scss partial elsewhere.
Internal Built-In Modules
You may have used built-in Sass functions in the past, such as
map.get. Most of these built-in functions will remain available, but not on a global level. This means that you will also need to import these *modules* using the new
@use import rule.
@use “sass:color”; or
@use “sass:math”; or
There are a total of seven built-in modules with very useful functions that you can import. You can read more about them here.
Partial files are formatted with an _ (underscore) at the beginning of the name such as
_.buttons.scss. These files are intended to be parts of a larger system. They are meant to be used as modules and not compiled on their own. I typically have partials roll up into the a main directory file (see next section) that is grouped by types of styles.
Index files are automatically loaded when you load the URL for the folder into the main stylesheet (
In the past, you may have created a partial directory file such as
_components-dir.scss that may have imported (
@import ) partial files such as
_buttons.scss. Now you simply have to either
@forward partials into an
_index.scss file within that folder, and make sure you
@use the folder name, in this case components, in your main
Your index file would look something like this:
// components/_index.scss@forward ‘labels’;
Your style file would then
@use the corresponding stylesheet:
// styles.scss@use ‘component’;
Note: Sass can also load plain
.cssfiles using the same
@use ‘avatar’;format! Just remember that plain
.cssfiles can’t take advantage of special Sass variables, functions or mixin features, but it can be extended using
extendin a Sass stylesheet.
After some digging, the
@forward rule is quite interesting. What it does is let your members, such as variables, of a forwarded stylesheet be accessible outside of the
@use stylesheet that imports it.
Using this rule follows a similar syntax as the other import rules:
Note: You can include both
@forwardrules for the same module in the same file but it is recommended that you write the
The new modular system that implements
@use is now available as of October 2019. As of October 2021
@import will be deprecated, along with global built-in functions, and one year after that (no later than October 2022)
@import support will be dropped. Make sure you go check out the newly refreshed Sass documentation for the latest updates.
I personally really enjoyed having globally-accessible variables with my Sass structure, and leaving the modularity to the folder structure itself. This worked for me because I was very meticulous about never using the same variable names, and I often had the liberty of setting up a project stylesheet system by myself, instead of working with several developers (at least usually not until everything was set up).
With that in mind and my personal preference in naming things, this is how I think I will be formatting my Sass folder and file structure in the future:
The key things to highlight in having this format are:
1. The main folder names have numbers in front of them, such as
0-base to ensure that the folders stay in that particular order. You can certainly omit this or choose different folder names.
2. The folder index files use
@forward with stylesheets that have members that I may want to use in other stylesheets so that they can be easily imported. For example, I import the
3-helpers files using
@use which then lets me freely use the color variables from the
_constants.scss file. You could theoretically do this with all index files, but if you want more control you can only
@forward the files that you want access to more frequently.
3. I rename the namespace of the
3-helper import so that I can use it freely without having to type the extra namespace characters —
color: $forestGreen versus
Tip: If you want to check out a different structure system, the 7–1 Sass architecture method is very well known and highly recommended by the Sass developers.