CSS custom properties vs SASS variables - Browser Rendering Compared

Render Flow - CSS custom properties vs SASS variables

Write SASS variables

→SASS compiler replaces variables

↓

Write CSS custom properties

→Browser reads CSS

SASS variables are replaced during compilation before the browser sees the CSS. CSS custom properties stay in the CSS and the browser applies them dynamically when rendering.

Render Steps - 3 Steps

Code Added:$bg-color: #ecf0f1;

Before

[box]
Text: default color
Background: default

→

After

[box]
Text: default color
Background: light gray (#ecf0f1)

SASS variable $bg-color sets the background color during compilation, so the box background becomes light gray.

🔧 Browser Action:SASS compiler replaces $bg-color with #ecf0f1 in CSS before browser renders

Code Sample

A box with text colored by a CSS custom property and background colored by a SASS variable.

SASS

<div class="box">Hello</div>

SASS

$bg-color: #ecf0f1;

:root {
  --main-color: #3498db;
}

.box {
  color: var(--main-color);
  background-color: $bg-color;
}

Render Quiz - 3 Questions

After step 3, what color is the box text?

A Default black

B Blue (#3498db)

C Light gray (#ecf0f1)

D Transparent

Common Confusions - 2 Topics

Why can't I change a SASS variable in the browser?

SASS variables are replaced during compilation, so the browser never sees them. Only CSS custom properties exist in the final CSS and can be changed dynamically.

💡 Remember: SASS variables = compile time, CSS custom properties = runtime (render_steps 1 and 3)

Why does var(--main-color) work in CSS but $main-color does not?

$main-color is a SASS variable and only works in SASS files before compilation. var(--main-color) is CSS syntax for custom properties that the browser understands.

💡 Use $ for SASS variables in SASS code, var() for CSS custom properties in CSS (render_steps 2 and 3)

Property Reference

Feature	SASS Variable	CSS Custom Property
Definition	Preprocessor variable replaced at compile time	CSS variable applied at runtime by browser
Syntax	$variable-name: value;	--variable-name: value;
Scope	Global or local in SASS files	Cascades like normal CSS properties
Dynamic changes	No, fixed after compilation	Yes, can change with JS or media queries
Browser support	N/A (compiled away)	Supported by modern browsers
Use case	Reusable values in SASS code	Theming and runtime style changes

Concept Snapshot

SASS variables use $ and are replaced during compilation. CSS custom properties use -- and exist in the CSS for the browser. SASS variables cannot change at runtime; CSS custom properties can. Use SASS variables for static values, CSS custom properties for dynamic theming. CSS custom properties cascade and can be accessed with var().

Practice

1. Which of the following is true about CSS custom properties compared to SASS variables?

easy

A. SASS variables start with -- and are dynamic in the browser.

B. SASS variables start with -- and work in the browser at runtime.

C. CSS custom properties start with $ and are replaced before the browser sees CSS.

D. CSS custom properties start with -- and work in the browser at runtime.

Solution

1. Step 1: Identify CSS custom properties syntax

   CSS custom properties always start with -- and are live in the browser, meaning they can be changed dynamically.

2. Step 2: Identify SASS variables syntax and behavior

   SASS variables start with $ and are replaced during the build process, so they don't exist in the browser.

3. Final Answer:

   CSS custom properties start with -- and work in the browser at runtime. -> Option D

4. Quick Check:

   CSS variables = -- prefix and runtime [OK]

Hint: CSS vars use -- and work live; SASS vars use $ and compile away [OK]

Common Mistakes:

• Confusing $ and -- prefixes
• Thinking SASS variables work in the browser
• Assuming CSS variables are replaced before runtime

2. Which is the correct way to declare a SASS variable for a color?

easy

A. primary-color: #3498db;

B. --primary-color: #3498db;

C. $primary-color: #3498db;

D. $primary-color == #3498db;

Solution

1. Step 1: Recall SASS variable syntax

   SASS variables start with $ and use a colon : to assign values.

2. Step 2: Check each option

   $primary-color: #3498db; uses correct syntax. --primary-color: #3498db; uses the CSS custom property prefix. primary-color: #3498db; omits the $ prefix. $primary-color == #3498db; uses double equals which is invalid.

3. Final Answer:

   $primary-color: #3498db; -> Option C

4. Quick Check:

   SASS variable = $name: value; [OK]

Hint: SASS vars start with $ and use colon for assignment [OK]

Common Mistakes:

• Using -- instead of $ for SASS variables
• Using == instead of : for assignment
• Omitting $ prefix

3. Given the following code, what color will the text be in the browser?

:root { --main-color: red; }
.box { color: var(--main-color); }
$main-color: blue;
.box2 { color: $main-color; }

medium

A. Both .box and .box2 text will be red

B. .box text will be red; .box2 text will be blue

C. .box text will be blue; .box2 text will be red

D. Both .box and .box2 text will be blue

Solution

1. Step 1: Understand CSS custom property usage

   The --main-color is set to red in :root. The class .box uses var(--main-color), so it will be red at runtime.

2. Step 2: Understand SASS variable usage

   The SASS variable $main-color is blue and used in .box2. This is replaced during compilation, so .box2 color will be blue in the final CSS.

3. Final Answer:

   .box text will be red; .box2 text will be blue -> Option B

4. Quick Check:

   CSS var = red; SASS var = blue [OK]

Hint: CSS vars live in browser; SASS vars replaced before browser sees CSS [OK]

Common Mistakes:

• Thinking SASS variables work at runtime
• Confusing which variable affects which class
• Assuming CSS variables are replaced before runtime

4. What is wrong with this SASS code snippet?

$color: green;
.text { color: var($color); }

medium

A. The var() function is only for CSS custom properties, not SASS variables.

B. The variable name should start with -- instead of $.

C. SASS variables cannot be used inside var() function.

D. The color value green is invalid.

Solution

1. Step 1: Understand var() function usage

   The var() function is a CSS function used only for CSS custom properties (those starting with --).

2. Step 2: Understand SASS variable usage

   SASS variables start with $ and are used directly without var(). Using var($color) is invalid because var() expects a CSS custom property name.

3. Final Answer:

   The var() function is only for CSS custom properties, not SASS variables. -> Option A

4. Quick Check:

   var() = CSS vars only, not SASS [OK]

Hint: Use $var directly in SASS; var() only for CSS custom properties [OK]

Common Mistakes:

• Using var() with SASS variables
• Confusing $ and -- prefixes
• Thinking var() works for SASS variables

5. You want to create a theme where users can switch colors dynamically in the browser. Which approach is best and why?

$primary-color: #0055ff;
:root { --primary-color: #0055ff; }

hard

A. Use CSS custom property --primary-color because it can change dynamically in the browser.

B. Use SASS variable $primary-color because it compiles faster.

C. Use both SASS and CSS variables together for better performance.

D. Use inline styles instead of variables for dynamic changes.

Solution

1. Step 1: Understand dynamic changes in the browser

   CSS custom properties (starting with --) live in the browser and can be changed with JavaScript or media queries without recompiling CSS.

2. Step 2: Understand SASS variable limitations

   SASS variables are replaced during build time and cannot change after the CSS is loaded, so they are not suitable for dynamic theming.

3. Final Answer:

   Use CSS custom property --primary-color because it can change dynamically in the browser. -> Option A

4. Quick Check:

   Dynamic theme = CSS vars [OK]

Hint: Dynamic changes need CSS vars; SASS vars are static [OK]

Common Mistakes:

• Choosing SASS variables for runtime changes
• Thinking both together improve dynamic behavior
• Ignoring CSS custom properties' runtime flexibility