Solidity compiler optimization in Blockchain / Solidity

Introduction

Solidity compiler optimization helps your smart contract run faster and use less gas, which saves money and improves performance.

When you want to reduce the cost of deploying a smart contract on Ethereum.

When you want your contract functions to execute more efficiently.

When you want to minimize the size of the compiled contract bytecode.

When you want to improve user experience by making transactions faster.

When you want to avoid hitting gas limits during contract execution.

Syntax

Blockchain / Solidity

solc --optimize --optimize-runs <number> YourContract.sol

Use --optimize to enable optimization.

--optimize-runs sets how often you expect functions to run; higher means better for repeated calls.

Examples

Enable basic optimization with default settings.

Blockchain / Solidity

solc --optimize YourContract.sol

Optimize assuming functions will be called about 200 times, balancing deployment size and runtime cost.

Blockchain / Solidity

solc --optimize --optimize-runs 200 YourContract.sol

Compile without optimization (default), which may cost more gas.

Blockchain / Solidity

solc YourContract.sol

Sample Program

This simple contract stores and returns a number. Using compiler optimization reduces gas cost when calling setData and getData.

Blockchain / Solidity

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract SimpleStorage {
    uint256 private data;

    function setData(uint256 _data) public {
        data = _data;
    }

    function getData() public view returns (uint256) {
        return data;
    }
}

// Compile with optimization:
// solc --optimize --optimize-runs 200 SimpleStorage.sol

Important Notes

Optimization can increase compile time but saves gas when running the contract.

Too high --optimize-runs may increase deployment cost but reduce runtime cost.

Always test your contract after enabling optimization to ensure behavior stays correct.

Summary

Compiler optimization reduces gas costs and contract size.

Use --optimize and --optimize-runs flags when compiling.

Balance optimization runs based on how often contract functions will be called.