Solidity has long stood as the bedrock of the decentralized finance and smart contract ecosystem. Securing hundreds of billions of dollars in economic value across various blockchain networks, the language has earned a reputation for generating robust and trustworthy code. However, as developers scale applications to unprecedented levels, the inherent limitations of Solidity’s classic implementation have become increasingly apparent. To address these growing pains, core contributors have officially announced "Core Solidity"—a comprehensive structural overhaul of the Solidity type system, compiler front end, and middle end designed to future-proof smart contract development.
For years, users have navigated the restrictions of the classic type system, which often lacks the expressive power needed to produce reusable library code or strictly enforce core safety properties at compile time. Furthermore, features offering compile-time evaluation have been extremely limited, and various components have suffered from inconsistent implementations. Attempting to patch these architectural bottlenecks within the existing codebase proved unsustainable. Ad-hoc upgrades made it increasingly difficult to reason about the correctness of subsequent changes, leaving maintainers unconfident about their ability to safely extend the language to meet modern demands.
Core Solidity emerges as the definitive solution to these structural hurdles. While not an entirely new language, it functions largely as a forward-looking extension that retains a familiar look and feel, ensuring that most existing Classic Solidity concepts seamlessly carry over.
A Note on Syntax
The engineering team has focused the vast majority of their initial efforts on designing and implementing a rigorous type system alongside an optimized code generation pipeline targeting Yul. To prevent project momentum from stalling over minor debates regarding syntax, the team elected to move forward with a provisional syntax in the early stages, relying on a working implementation to validate core ideas quickly.
Developers should expect extensive modifications to the syntax prior to the official release. The long-term vision is to gradually align the syntax closely with Classic Solidity, while ensuring that any entirely new syntactic elements feel native to modern systems languages such as TypeScript or Rust.
New Language Features
Drawing direct inspiration from pure functional programming languages like Haskell and Lean, as well as modern systems languages like Rust and Zig, Core Solidity introduces a powerful suite of new features. These foundational primitives are engineered to empower developers to forge stronger abstractions, write deeply modular and reusable code, and harness the type system to enforce airtight safety properties.
Despite the addition of high-level abstractions, the project remains fully committed to supporting the low-level EVM access essential for production-grade implementations. Assembly will continue to serve as a core primitive, enhanced with the capability to call functions defined in the high-level language directly. Following the "pay for what you use" philosophy championed by languages like C++ and Rust, developers will retain the flexibility to disable built-in abstractions—such as contract dispatch generation, ABI decoding, or default storage layout generation—whenever maximum control is required.
Algebraic Data Types and Pattern Matching
Among the most impactful additions are algebraic data types (ADTs), which provide a principled foundation for data modeling through the composition of sum and product types. Representing an evolution of traditional enums, sum types denote exclusive alternatives where a value inhabits exactly one variant, while product types combine multiple values into structured tuples. Together, they allow developers to define precise types that render invalid states completely unrepresentable.
This capability shines when implementing patterns similar to user-defined value types in Classic Solidity. For instance, a fixed-point decimal representation can be wrapped cleanly while maintaining an identical runtime representation to a standard uint256 once the compiler erases simple wrapper types during translation to Yul.
Complementing ADTs is comprehensive pattern matching, a control flow mechanism that replaces cumbersome, nested if-else chains with declarative expressions. Pattern matching allows developers to destructure and inspect data by shape while the compiler rigorously enforces exhaustiveness, ensuring that every conceivable state alternative is handled safely and explicitly.
Generics and Type Classes
Core Solidity introduces parametric polymorphism via generics, enabling developers to write functions and data structures that behave uniformly across all types. To handle scenarios where operations are restricted to specific subsets of types, the language implements type classes—often known as traits in other ecosystems. Type classes define interface specifications that allow for overloaded implementations of identical function signatures across different types.
By combining generics with type class constraints, developers can eliminate massive amounts of boilerplate code. For example, traditional logging libraries often require a combinatorial explosion of function overloads to handle various data types. Core Solidity addresses this by allowing a single generic function constrained by type classes to handle disparate inputs efficiently. Following the lead of languages like Rust and Lean, all type class invocations and generic functions are fully monomorphized at compile time, ensuring that polymorphic abstractions incur zero runtime gas overhead compared to concrete implementations.
Higher-Order and Anonymous Functions
Functions now enjoy true first-class status within the type system, granting developers the ability to pass them as parameters, return them from other routines, and assign them to variables. This unlocks advanced architectural patterns—such as custom ABI decoding wrappers and higher-order decorators—that were previously impossible to implement in Classic Solidity, even with traditional modifiers.
Additionally, the language supports non-recursive anonymous functions using the lam keyword, which can seamlessly capture values from their surrounding lexical scope. The compiler translates these closures into unique, callable types optimized for runtime gas efficiency through specialized type class instances.
Type Inference and Compile-Time Evaluation
The inclusion of a robust, constraint-based type inference algorithm significantly reduces syntactic clutter across the codebase. Type annotations are now optional in almost all positions, reserved primarily for enhancing readability where desired. This advanced inference successfully resolves frustrating edge cases present in Classic Solidity, such as strict array literal typing requirements.
Although compile-time evaluation is still in its early developmental phases, it stands as a top priority for the engineering roadmap. The team aims to deliver a general-purpose feature that minimizes discrepancies between runtime and compile-time contexts, facilitating seamless code sharing and advanced reflection capabilities.
SAIL, Desugaring, and the Standard Library
The structural backbone of Core Solidity is SAIL, or Solidity Algebraic Intermediate Language. Serving as a user-accessible, mid-level intermediate representation, SAIL provides the absolute minimum set of constructs necessary to express the full range of high-level language features found in Classic Solidity. SAIL operates on a foundational word type analogous to an EVM stack slot, maintaining a close relationship with Yul while remaining flexible enough to theoretically target alternative assembly backends.
By leveraging SAIL, the development team can implement all high-level language constructs and types through standard library definitions and desugaring passes—compile-time transformations into SAIL primitives. This design mirrors practices common in high-assurance domains like theorem provers, opening the door for an executable formal semantics. Such semantics will allow maintainers to mathematically guarantee core safety properties, verify standard library implementations, and foster a community-driven, RFC-style evolution for future language upgrades.
Compatibility and Interoperability
Navigating a major paradigm shift without fracturing the developer community remains a paramount priority. Inspired by versioning models like Rust’s editions, the transition plan maintains strict ABI compatibility between versions. This ensures that contracts written in different language iterations can interoperate seamlessly within the same project.
While syntactic and semantic changes are inevitable—most notably the complete removal of inheritance and the potential reworking of constructs like try/catch and data locations—the team is committed to minimizing unnecessary friction. Automated upgrade tools are currently under investigation to ease the migration process, ensuring that developers can adopt Core Solidity incrementally.
The Road to Production
A working prototype of Core Solidity is already available for experimentation in the dedicated solcore GitHub repository. While the current prototype successfully typechecks programs and generates Yul bytecode, substantial work remains. The team plans to finalize the type system, build out a comprehensive standard library, integrate a robust module system, and gather extensive feedback from power users and library authors before declaring the language production-ready.
Once the prototype reaches stability, development will branch into parallel streams to prepare a production-grade compiler frontend. Following a comprehensive period of real-world testing, fuzzing, and external reviews, a breaking version of the Solidity compiler will be released with Core Solidity set as the default standard.
As development presses forward, the community is invited to explore the repository, experiment with the prototype, and contribute feedback through the official Solidity forum discussion threads to help shape the future of smart contract development.






