solar

Blazingly fast, modular and contributor friendly Solidity compiler, written in Rust.

Features and Goals

Warning

Solar is under active development and is not yet feature complete. Use it to speed up your development workflows and tooling. Please do not use it in production environments.

• ⚡ Instant compiles and low memory usage (benchmarks)
• 🔍 Expressive and useful diagnostics
• 🧩 Modular, library-based architecture
• 💻 Simple and hackable code base
• 🔄 Compatibility with the latest Solidity language breaking version (0.8.*)

Performance

On six real-world projects, builds were about 100× faster on average than solc's via-IR pipeline, reaching 159× on Morpho Blue.

We forced via-IR on every project for solc, though most of these projects build without it by default. We picked six of the ten whole-project cases in our benchmark suite: v4-core has no solc result, and Seaport, Solmate and Solarray are not shown. With each project's own settings, from the same CI run, we were 44× faster on average over the six and 34× over all nine.

We measured on main at commit 0303bb7d against solc 0.8.38, targeting Cancun. Build from source to match it. Build times are the median of five runs on an AMD EPYC 9254 (24 cores), using our default eight threads; solc is single-threaded.

Across the 15 real-world contracts in our runtime corpus (via-IR at 200 runs, unless a case pins its project's settings), the generated contracts used 5% less gas, cost 26% less gas to deploy and had 29% smaller bytecode than those compiled with solc, as geometric means. See the results and benchmark instructions for inputs, settings and how to reproduce them.

How it works

MIR keeps Solidity types and operations, so passes can remove redundant checks, inline functions and avoid repeated storage and memory accesses. EVM IR handles stack operations, block layout, tail merging and peephole rewrites before assembly.

See the MIR reference and codegen guide to work on the compiler.

Getting started

Solar is available through a command-line interface, or as a Rust library.

Library usage

You can add Solar to your Rust project by adding the following to your Cargo.toml:

[dependencies]
solar = { version = "=0.2.0", package = "solar-compiler", default-features = false }

Or through the CLI:

cargo add "solar-compiler@=0.2.0" --rename solar --no-default-features

You can see examples of how to use Solar as a library in the examples directory.

Binary usage

Install Foundry, then choose the compiler with --use solar:

foundryup
forge build --use solar
forge test --use solar

Pre-built binaries are available for macOS, Linux and Windows on the releases page and can be installed with the following commands:

• On macOS and Linux:

  curl -LsSf https://paradigm.xyz/solar/install.sh | sh

• On Windows:

  powershell -c "irm https://paradigm.xyz/solar/install.ps1 | iex"

• For a specific version:

  curl -LsSf https://paradigm.xyz/solar/v0.2.0/install.sh | sh
  powershell -c "irm https://paradigm.xyz/solar/v0.2.0/install.ps1 | iex"

You can also use cargo binstall:

• Latest version:

  cargo binstall solar-compiler

• For a specific version:

  cargo binstall solar-compiler@0.2.0

Or build Solar from source:

• From crates.io:

  cargo install solar-compiler --locked

• From GitHub:

  cargo install --git https://github.com/paradigmxyz/solar --locked

• From a Git checkout:

  git clone https://github.com/paradigmxyz/solar
  cd solar
  cargo install --locked --path crates/solar

Once installed, check out the available options:

solar -h

Here's a few examples:

# Compile a single file and emit ABI to stdout.
solar Counter.sol --emit abi

# Compile a contract through standard input (`-` file).
echo "contract C {}" | solar -
solar - <<EOF
contract HelloWorld {
    function helloWorld() external pure returns (string memory) {
        return "Hello, World!";
    }
}
EOF

# Compile a file with a Foundry project's remappings.
solar $(forge re) src/Contract.sol

Editor integrations

The VS Code and Zed clients are maintained by Foundry. Use forge lsp to launch Foundry's editor integration. This repository continues to provide the Solar LSP server used by Foundry.

C API, WASM, and JavaScript usage

The solar-capi crate exposes the compiler through a Solidity-compatible C API, a WebAssembly build and a soljson-compatible JavaScript wrapper. See its README for the C API and for how to download or build the wasm distribution and use it from JavaScript.

Semver Compatibility

Solar's versioning tracks compatibility for the binaries, not the API. If using this as a library, be sure to pin the version with a = version requirement operator.

Supported Rust Versions (MSRV)

Solar always aims to stay up-to-date with the latest stable Rust release.

The Minimum Supported Rust Version (MSRV) may be updated at any time, so we can take advantage of new features and improvements in Rust.

Contributing

Contributions are welcome and highly appreciated. To get started, check out the contributing guidelines.

Support

Having trouble? Check out the existing issues on GitHub, or feel free to open a new one.

You can also ask for help on Telegram.

License

^{Licensed under either of Apache License, Version 2.0 or MIT license at your option.}
_{Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in these crates by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.}