{"id":4330,"date":"2026-11-20T23:15:17","date_gmt":"2026-11-20T23:15:17","guid":{"rendered":"https:\/\/smartcryptosecurity.com\/?p=4330"},"modified":"2026-11-20T23:15:17","modified_gmt":"2026-11-20T23:15:17","slug":"solidity-compiler-v0-8-35-released-with-first-comptime-builtin-experimental-ssa-cfg-code-generator-and-upcoming-0-9-0-deprecations","status":"publish","type":"post","link":"https:\/\/smartcryptosecurity.com\/?p=4330","title":{"rendered":"Solidity Compiler v0.8.35 Released with First Comptime Builtin, Experimental SSA CFG Code Generator, and Upcoming 0.9.0 Deprecations"},"content":{"rendered":"<p>The development team behind the Solidity programming language has officially announced the release of the Solidity Compiler version v0.8.35. Building upon a busy cycle of updates and pre-releases, this latest version introduces significant improvements to developer tooling, lays down a formal framework for handling experimental features, and introduces the language&#8217;s very first compile-time (comptime) builtin function. The update also continues the ongoing preparation work for the eventual release of Solidity 0.9.0 by issuing crucial deprecation warnings for upcoming keyword promotions.<\/p>\n<p>Some of the groundbreaking features included in this stable release were initially previewed earlier in the year within the v0.8.35-pre.1 pre-release. By bringing these tools into the main release channel, the Solidity core team is offering smart contract developers a cleaner, more robust, and more future-proof development experience across both standard and intermediate representation (IR) compilation pipelines.<\/p>\n<h2>Notable Features and Changes<\/h2>\n<p>The release of Solidity v0.8.35 brings a robust mix of language-level additions, structural modifications to how experimental features are handled, and critical bug fixes. The most impactful changes revolve around storage layout optimization, a newly formalized experimental process, and a brand-new code generator designed to tackle some of the ecosystem&#8217;s most persistent pain points.<\/p>\n<h3>The erc7201 Comptime Builtin<\/h3>\n<p>One of the standout additions in Solidity 0.8.35 is the introduction of a new builtin function: <code>erc7201(string memory id) returns (uint)<\/code>. This function computes the base storage slot for a namespace string using the precise formula defined in the Ethereum Improvement Proposal ERC-7201, which is mathematically equivalent to <code>keccak256(keccak256(id) - 1) &amp; ~0xff<\/code>. <\/p>\n<p>ERC-7201 formalizes the widespread industry practice of placing a smart contract&#8217;s state behind a hashed namespace. This approach is vital for preventing storage collisions in proxy-based and diamond-style upgradeable contract patterns. The new builtin pairs naturally with the <code>layout at<\/code> storage layout specifier that was originally introduced in version 0.8.29 and subsequently extended in version 0.8.31.<\/p>\n<p>What makes <code>erc7201<\/code> truly unique is that it marks the very first comptime builtin in the language. Until now, Solidity&#8217;s comptime evaluator was strictly limited to performing arithmetic operations on rational number literals. While existing builtins like <code>keccak256<\/code> have historically undergone constant folding during the optimization stage of code generation\u2014allowing developers to reap gas savings\u2014they lacked the type-system benefit of being usable in a compile-time context, such as a layout specifier or an array length definition. <\/p>\n<p>By allowing <code>erc7201<\/code> to be used wherever a comptime expression is required, this release directly addresses limitations previously flagged by the development team, paving the way for a much more capable comptime evaluator in future versions of the compiler.<\/p>\n<h3>Formalizing the Experimental Feature Process<\/h3>\n<p>In past releases, the Solidity compiler has shipped various in-development features that could be unlocked through an ad-hoc mix of command-line interface flags and <code>pragma experimental<\/code> directives. This decentralized approach meant there was no consistent, unified way for developers to recognize when they were opting into unstable functionality, and metadata signaling remained patchy at best.<\/p>\n<p>Solidity 0.8.35 introduces a comprehensive formalization of this process, documented thoroughly in the newly updated Experimental Mode documentation. The most visible manifestation of this change is the introduction of a new top-level <code>--experimental<\/code> flag, along with its boolean counterpart <code>settings.experimental<\/code> in Standard JSON input configurations.<\/p>\n<p>The <code>--experimental<\/code> flag serves strictly as a master toggle. On its own, it does not activate any specific feature, but it is now mandatory if a developer wishes to use any per-feature flags or pragmas. Attempting to use experimental features without the master toggle now results in a hard compilation error. <\/p>\n<p>Developers who were already passing affected flags directly will need to update their workflows to include <code>--experimental<\/code> or set <code>settings.experimental: true<\/code> in their JSON inputs to keep their builds functioning. This adjustment does not represent a backwards-compatibility break, as experimental features have traditionally been excluded from stability guarantees. Instead, it makes those risks explicit, ensuring that no developer accidentally opts into unstable functionality that carries no stability guarantees and may change in breaking ways even during minor releases.<\/p>\n<p>Furthermore, whether a contract was compiled with experimental mode enabled is now permanently recorded in both JSON and CBOR metadata. The CBOR <code>experimental<\/code> field, which previously only indicated experimental pragmas present in the source code, has been broadened to cover this entire mode, successfully closing a known oversight where targeting unreleased EVM versions could produce experimental bytecode without signaling the flag.<\/p>\n<h3>Experimental SSA CFG Code Generator<\/h3>\n<p>Solidity 0.8.35 also ships an experimental new EVM backend for the IR pipeline. This backend generates bytecode directly from the program&#8217;s static single-assignment (SSA) form control-flow graphs (SSA CFGs), utilizing a precomputed stack layout that the backend subsequently shuffles the EVM stack to match.<\/p>\n<p>The rationale behind building this new code generator lies in two long-standing pain points for the IR pipeline: excessively slow compilation times and the dreaded stack-too-deep errors. Stack-too-deep errors consistently rank as the most commonly reported recurring issue among smart contract developers, as highlighted in recent developer surveys, and compilation via IR has historically been measurably slower than the traditional evmasm pipeline. <\/p>\n<p>The legacy Yul-to-EVM code transformation relies heavily on heuristics that often struggle when confronted with deeply nested expressions and complex control flow. An SSA-based backend provides a much stronger foundation for both stack scheduling and compilation performance, representing the most realistic long-term solution to these bottlenecks. <\/p>\n<p>Developers can test this code generator by passing <code>--experimental --via-ssa-cfg<\/code> on the command line, or by configuring <code>settings.experimental: true<\/code> alongside <code>settings.viaSSACFG: true<\/code> in Standard JSON inputs. Both options automatically imply <code>--via-ir<\/code>. While the codegen is continuously tested against the full external-contract semantic test suite on every pull request, it remains an early experimental release. It is not yet the default option for <code>--via-ir<\/code>, and gas benchmarking alone will not be sufficient to promote it; the team plans to subject it to thorough review, extensive fuzzing, and external auditing before making it the standard.<\/p>\n<h3>Deprecation Warnings for Upcoming 0.9.0 Keywords<\/h3>\n<p>Continuing the deprecation work that began in version 0.8.31, this release introduces warnings for identifiers that the core team plans to formally promote to keywords in the upcoming major release, Solidity 0.9.0. While the previous deprecations focused primarily on removing obsolete features, this batch centers entirely on claiming names to prevent future conflicts.<\/p>\n<p>Solidity declarations utilizing identifiers such as <code>at<\/code>, <code>error<\/code>, <code>layout<\/code>, <code>leave<\/code>, <code>super<\/code>, <code>this<\/code>, or <code>transient<\/code> will now emit a warning. Within Yul, whether used standalone or within inline assembly blocks, <code>leave<\/code> is slated to become a Yul keyword, while <code>basefee<\/code>, <code>blobbasefee<\/code>, <code>blobhash<\/code>, <code>clz<\/code>, <code>mcopy<\/code>, <code>memoryguard<\/code>, <code>prevrandao<\/code>, <code>tload<\/code>, and <code>tstore<\/code> will become reserved Yul identifiers. Because these latter terms are standard Yul builtins that are typically kept reserved, the growing list of exceptions is a byproduct of the unusually long 0.8.x release cycle, as the compiler&#8217;s strict backwards-compatibility policy holds them until the 0.9.0 boundary.<\/p>\n<p>These notifications are issued purely as warnings rather than hard errors. Existing codebases will continue to compile successfully, giving developers an adequate window to rename affected declarations well before version 0.9.0 turns these warnings into breaking compilation errors.<\/p>\n<h3>Revert Strings Strip and Custom Errors<\/h3>\n<p>Another notable fix addresses an interaction between optimization flags and custom errors. The option <code>--revert-strings strip<\/code> (or <code>revertStrings: \"strip\"<\/code> in Standard JSON) is a popular gas-saving feature that strips revert reason strings from the generated bytecode while ensuring that reverts still occur. The implicit assumption behind this setting has traditionally been that returndata serves merely as a human-readable message rather than structured data that dependent contracts should rely upon.<\/p>\n<p>The introduction of <code>require(condition, CustomError(...))<\/code> in version 0.8.26 complicated this assumption because custom errors explicitly encode structured data. Until version 0.8.35, the IR pipeline would aggressively strip the custom-error argument of a <code>require<\/code> statement alongside standard strings, resulting in failed <code>require<\/code> calls reverting with empty error data instead of the properly encoded custom error. Meanwhile, the legacy evmasm pipeline handled this differently, creating an inconsistency between pipelines. The development team resolved this discrepancy by ensuring that custom errors are preserved, avoiding a scenario where stripping revert strings would inadvertently destroy structured error data. This fix applies specifically to <code>require()<\/code> statements utilizing custom errors within the IR pipeline.<\/p>\n<h3>Ethdebug Output Reorganization<\/h3>\n<p>Finally, this release reorganizes the output selection for ethdebug to make it more granular and consistent with how other compiler outputs are exposed. The old <code>--ethdebug<\/code> and <code>--ethdebug-runtime<\/code> flags have been replaced by <code>--ethdebug-resources<\/code>, <code>--ethdebug-compilation<\/code>, <code>--ethdebug-program<\/code>, and <code>--ethdebug-program-runtime<\/code>, with corresponding keys introduced in Standard JSON. Ethdebug outputs no longer force a full binary compilation by default, and the tool remains experimental, appropriately gated behind the new <code>--experimental<\/code> flag alongside other unstable features.<\/p>\n<h2>How to Install and Upgrade<\/h2>\n<p>Developers wishing to upgrade to the latest iteration of the compiler can consult the official installation instructions available in the Solidity documentation. The release packages and binaries can be downloaded directly from the official GitHub repository under release tag v0.8.35.<\/p>\n<p>For those compiling the software directly from source, the development team strongly advises against using the automatically generated source archives provided by GitHub. Instead, developers should utilize the official <code>solidity_0.8.35.tar.gz<\/code> source tarball or check out the exact <code>v0.8.35<\/code> tag via git to ensure a reliable and verifiable build. The core team has expressed gratitude to all community contributors who tested pre-releases, reported bugs, and helped bring this major release to completion.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>The development team behind the Solidity programming language has officially announced the release of the&#8230;<\/p>\n","protected":false},"author":4,"featured_media":4329,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[366],"tags":[401,2382,406,1230,2381,2596,2183,15,407,2001,5,400,402,1130],"class_list":["post-4330","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-smart-contract-auditing","tag-auditing","tag-builtin","tag-code","tag-compiler","tag-comptime","tag-deprecations","tag-experimental","tag-first","tag-generator","tag-released","tag-security","tag-smart-contracts","tag-solidity","tag-upcoming"],"_links":{"self":[{"href":"https:\/\/smartcryptosecurity.com\/index.php?rest_route=\/wp\/v2\/posts\/4330","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/smartcryptosecurity.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/smartcryptosecurity.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/smartcryptosecurity.com\/index.php?rest_route=\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/smartcryptosecurity.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=4330"}],"version-history":[{"count":0,"href":"https:\/\/smartcryptosecurity.com\/index.php?rest_route=\/wp\/v2\/posts\/4330\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/smartcryptosecurity.com\/index.php?rest_route=\/wp\/v2\/media\/4329"}],"wp:attachment":[{"href":"https:\/\/smartcryptosecurity.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=4330"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/smartcryptosecurity.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=4330"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/smartcryptosecurity.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=4330"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}