Benchmark: Test: CSS calc() with var() - 02

HTML Preparation code:

<section id="section"></section>

Script Preparation code:

const section = document.getElementById("section");

section.style.setProperty('--translation', '100');
section.style.setProperty('--translationPx', '100px');
section.style.setProperty('--translationPercentage', '100%');


for (var i = 0; i < 1000; i++) {
    const newDiv = document.createElement("div");
    const text = document.createTextNode(`${i}`);
    newDiv.appendChild(text);
    section.appendChild(newDiv);
}

var nodes = document.querySelectorAll("div");

Tests:

calc() * 2
for (var i = 0; i < nodes.length; i++) { nodes[i].style = "transform: translateY(calc(var(--translation) * 2))" }
calc() * 0.5
for (var i = 0; i < nodes.length; i++) { nodes[i].style = "transform: translateY(calc(var(--translation) * 0.5))" }
calc() * -0.5
for (var i = 0; i < nodes.length; i++) { nodes[i].style = "transform: translateY(calc(var(--translation) * -0.5))" }
calc() / 2
for (var i = 0; i < nodes.length; i++) { nodes[i].style = "transform: translateY(calc(var(--translation) / 2))" }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
calc() * 2
calc() * 0.5
calc() * -0.5
calc() / 2

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
calc() * 2	1038.6 Ops/sec
calc() * 0.5	1008.9 Ops/sec
calc() * -0.5	1000.2 Ops/sec
calc() / 2	984.8 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON focuses on testing the performance of CSS `calc()` together with the CSS variable function `var()` across various mathematical operations, specifically multiplying and dividing a CSS variable. The objective is to compare the performance of these CSS calculations against standard units in a DOM structure populated with `div` elements.

### Overview of the Benchmark

1. **Description**: The test aims to evaluate the performance difference between using `calc()` with dynamic variables (set via CSS custom properties) and using simple unit values within CSS transformations for various arithmetic operations (multiplication and division).

2. **Setup**:
    - The HTML structure consists of a `<section>` element, which contains multiple `<div>` children (in this case, 1000).
    - The CSS custom properties `--translation`, `--translationPx`, and `--translationPercentage` are set to '100', '100px', and '100%', respectively.
    - The benchmark code runs transformations on each of the `div` elements using the `transform` property.

### Test Cases Compared

1. **Benchmark Name: `calc() * 2`**

- **Code**: `transform: translateY(calc(var(--translation) * 2))`
   - **Purpose**: Translates the `div` `y` position by doubling the value of the CSS variable.
   - **Performance**: Highest among the tests listed.

2. **Benchmark Name: `calc() * 0.5`**

- **Code**: `transform: translateY(calc(var(--translation) * 0.5))`
   - **Purpose**: Translates the `div` `y` position to half the value of the CSS variable.
   - **Performance**: Slightly lower than "calc() * 2".

3. **Benchmark Name: `calc() * -0.5`**

- **Code**: `transform: translateY(calc(var(--translation) * -0.5))`
   - **Purpose**: Translates the `div` negatively by half the value of the CSS variable.
   - **Performance**: Generally the lowest performance.

4. **Benchmark Name: `calc() / 2`**

- **Code**: `transform: translateY(calc(var(--translation) / 2))`
   - **Purpose**: Translates the `div` to half the value of the variable in a division context.
   - **Performance**: Very close in execution time to "calc() * 0.5".

### Performance Results

The rendering speeds are measured in executions per second:

- `calc() * 2`: 336.54 executions per second (fastest).
- `calc() / 2`: 336.35 executions per second.
- `calc() * 0.5`: 335.35 executions per second.
- `calc() * -0.5`: 332.23 executions per second (slowest).

### Pros and Cons of Using `calc()` with `var()`

#### Pros:
- **Dynamic Calculation**: Using `calc()` allows for more flexibility in CSS, especially when combined with CSS variables. You can easily change the values of those variables in one place without needing to edit multiple properties.
- **Responsive Design**: Beneficial for responsive designs where element positioning may need to adapt dynamically based on different viewport sizes.

#### Cons:
- **Performance Overhead**: The use of `calc()` introduces additional computation at runtime for rendering. The benchmarks indicate that while the performance is decent, it may not match the efficiency of static values.
- **Complexity**: It may introduce complexity to the CSS if overused or poorly managed!

### Alternative Approaches

1. **Static Value Usage**: Instead of using dynamic calculations like `calc()`, developers can use static pixel values or percentages, which would be directly performant with no computation needed at runtime.

2. **CSS Transitions and Animations**: For animations that need to leverage dynamic calculations, similar effects could be achieved using CSS transitions or animations based on predefined keyframes.

3. **Precomputed Styles**: When the transformations do not need to be dynamic, precomputing those styles on the server-side and sending them directly to the client can enhance performance.

### Conclusion

This benchmark provides valuable insights into how different arithmetic operations using `calc()` and `var()` impact CSS rendering performance. As web developers consider dynamic styling and responsive design approaches, understanding the trade-offs between performance and flexibility is crucial, especially in complex user interfaces that require extensive DOM manipulation and rendering optimizations.

Related benchmarks:

Test: CSS calc() with var() - 02 (version: 1)

Test difference in performance with calc() and var() functions compared with simple units. Test on unitless, percentage and absolute values.

Comparing performance of: calc() * 2 vs calc() * 0.5 vs calc() * -0.5 vs calc() / 2

Created: 2 months ago by: Guest

Jump to the latest result

calc() * 2

calc() * 0.5

calc() * -0.5

calc() / 2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):