Solidity, the dominant programming language securing hundreds of billions of dollars in decentralized finance and smart contract value across the blockchain ecosystem, is undergoing a profound structural evolution. Developers behind the language have announced "Core Solidity," an ambitious, ground-up reconstruction of the Solidity type system and its compiler front and middle ends designed to eliminate long-standing architectural limitations and scale effectively for future demands.
While Classic Solidity has earned a stellar track record for robust and trustworthy code generation, its maintainers acknowledge that the language’s existing design contains inherent constraints. The current type system frequently lacks the expressiveness required to produce truly reusable library code or to cleanly enforce core safety properties at compile time. Furthermore, support for compile-time evaluation has remained severely restricted, and numerous features have historically been implemented in an ad-hoc or inconsistent manner.
Attempting to patch these limitations within the framework of the current implementation has proven increasingly difficult. Upgrades must often be handled cautiously because each incremental addition makes it progressively harder to reason about the correctness of subsequent modifications. Lacking confidence that the legacy structure could safely absorb the sophisticated features requested by users and required by modern high-scale blockchain systems, the core team initiated the development of Core Solidity.
A New Foundation Through SAIL and Modern Type Theory
At the heart of Core Solidity is SAIL, or Solidity Algebraic Intermediate Language, which acts as a minimal, user-accessible mid-level IR. SAIL serves as the foundational layer capable of expressing the full range of high-level language constructs found in Classic Solidity. Built around a single primitive type known as a word—which mirrors the range of values found in a 32-byte EVM stack slot—SAIL operates similarly to Yul by functioning both as a compiler intermediate representation and a user-facing low-level language.
By grounding Core Solidity in SAIL, the development team anticipates constructing an executable formal semantics. This mathematical framework will allow developers to mathematically guarantee core safety properties of the type system, provide a reliable reference implementation for differential fuzzing, and formally verify both the standard library and higher-level abstractions. Library authors will inherit nearly the same expressive power as the original language designers, enabling them to construct custom abstractions that feel native to the language itself.
Despite these deep structural changes, Core Solidity is not pitched as an entirely alien language, but rather as a powerful extension of Classic Solidity. It retains a familiar look and feel, ensuring that most existing concepts easily carry over. However, the upgrade path will involve shedding certain problematic components. Most notably, the team has confirmed plans to remove inheritance entirely, while actively considering the replacement or radical reworking of legacy features such as try/catch blocks, libraries, function pointers, type conversions, and data locations.
Advanced Language Features Inspired by Modern Systems and Functional Programming
Drawing inspiration from pure functional programming languages like Haskell and Lean, alongside modern systems languages such as Rust and Zig, Core Solidity introduces several powerful programming primitives designed to foster modularity and compile-time safety.
Among the marquee additions are algebraic data types (ADTs) and pattern matching. ADTs combine sum types—an advanced evolution of classic enums representing exclusive alternatives—with product types that group multiple values into structured tuples. Together, these constructs allow developers to design precise types that render invalid states completely unrepresentable. Accompanying this is exhaustive pattern matching, which replaces nested conditional chains with declarative expressions checked directly by the compiler.
The language also introduces generics and type classes, bringing parametric polymorphism and trait-based interfaces to smart contract development. Developers can write uniform functions and generic data structures constrained by specific type class instances. Crucially, all generic functions and type class invocations are fully monomorphized at compile time in a manner similar to Rust, ensuring that polymorphic abstractions incur zero runtime gas overhead compared to concrete implementations.
First-class functions and anonymous closures further expand the language’s capabilities. Functions can now be passed as parameters, returned from other routines, and assigned to variables. Anonymous functions using the lam keyword can safely capture variables from their defining scope, backed by a runtime-efficient representation where each closure is assigned a unique type made callable via an invokable type class.
Type inference has likewise been overhauled. Core Solidity features a constraint-based inference algorithm capable of deducing types across nearly all code positions, drastically reducing syntactic clutter and eliminating frustrating edge cases like those previously encountered with array literals. Meanwhile, work is actively underway to introduce a general-purpose compile-time evaluation mechanism that shares syntax seamlessly with the runtime context.
Compatibility, Interoperability, and the Road to Production
Transitioning an ecosystem as massive as Solidity requires a deliberate strategy to prevent fragmentation. Drawing lessons from other major language transitions, the core team plans to maintain strict ABI compatibility between versions, allowing contracts written in Classic and Core Solidity to interoperate seamlessly side by side within the same project environment, mirroring the edition strategies utilized in systems like Rust. Furthermore, the team is exploring deeper interoperability, potentially allowing the sharing of free functions and interface definitions across versions.
While a working prototype of Core Solidity is already operational and available for experimentation on GitHub via the solcore repository, the project remains in an active development phase. The current prototype successfully typechecks programs and generates executable code down to Yul, supporting fundamental Classic Solidity features including contract dispatch, ABI encoding and decoding, and storage access.
However, extensive work remains before production readiness. The team intends to finalize the type system—integrating upcoming features like compile-time evaluation and a comprehensive module system—flesh out the standard library, and gather feedback from power users and library authors. Once the prototype reaches stability, development will branch into parallel streams to prepare the infrastructure for a future breaking release of the solc compiler, where Core Solidity will ultimately become the default language version for the ecosystem.

