Core Solidity Status Update: Prototype Evolves with Algebraic Data Types, Pattern Matching, and Modular Composition

The development team behind Core Solidity has released a comprehensive status update detailing the ongoing evolution of the language’s prototype compiler. Reflecting the state of the project as of early October 2026, the report outlines significant syntax adjustments, community feedback gathered from extensive qualitative interviews, and the roadmap leading toward future releases. Designed as an advanced frontend for solc, Core Solidity aims to introduce modern programming language paradigms—such as algebraic data types, pattern matching, generics, traits, and compile-time evaluation—while maintaining the robust, battle-tested backend infrastructure of the existing Solidity ecosystem.

Contrary to common misconceptions circulating within the developer community earlier this year, Core Solidity does not seek to replace the entire compiler stack. Instead, the innovative frontend compiles down to Yul, handing off the resulting intermediate representation to the established optimizer and code generator utilized by Classic Solidity. This architectural strategy allows the project to leverage the foundational performance and security enhancements of the traditional backend, including ongoing work on experimental code generators, while completely rethinking how developers write and structure smart contracts.

Over the summer, the development team significantly reworked the language syntax to bridge the gap with Classic Solidity, making the transition smoother for existing developers. While earlier provisional syntax configurations no longer compile, the core concepts remain fully intact. Modern Core Solidity code features distinctive postfix types where types follow names, such as phase: Phase and amount: uint256. Furthermore, the language enforces strict scoping rules: aside from a minimal set of built-in types, virtually nothing is in scope unless explicitly imported. This includes the standard library, fundamental types, and dispatch logic.

A primary highlight of the current prototype is the implementation of algebraic data types, exemplified by enum variants capable of carrying complex data, alongside exhaustive pattern matching via match statements. In practice, writing a state-managed contract like an escrow service demonstrates how these features work together. When a developer builds an escrow lifecycle using a custom Phase enum, the compiler actively ensures safety by rejecting any match statement that leaves a case unhandled without a corresponding default arm.

Although the prototype successfully compiles complex port implementations—including the Ethereum deposit contract, WETH9, and a minimal ERC20 token—the team acknowledges several ongoing rough edges and missing features. Custom errors are not yet available, meaning current reverts rely on plain strings, and minor syntactic workarounds remain necessary in certain control flows. Additionally, crucial production-ready features such as events, structs in the web-based playground, and typed external calls are either under active development or targeted for upcoming pull requests. Gas optimization and code size comparisons against Classic Solidity have not yet been prioritized, as the primary focus remains on refining language design and semantics.

To formalize the theoretical foundations of the language, developers are actively working on specifying the semantics of Core Solidity using the Lean 4 proof assistant within a dedicated repository. Meanwhile, the web-based playground continues to serve as the most accessible environment for experimentation, allowing engineers to examine generated bytecode, test interactive contracts, and explore advanced architectural patterns like multi-vault compositions and modular extensions.

Since March 2026, the core team has conducted 18 qualitative interviews with protocol engineers, security auditors, educators, tool maintainers, and language researchers. These discussions have provided critical qualitative feedback on the language’s trajectory. Reviewers have responded exceptionally well to algebraic data types and pattern matching, specifically praising the compiler’s safety check against forgotten match cases. Security professionals have also expressed strong support for the project’s approach to modular composition, which deliberately moves away from traditional object-oriented inheritance.

By eliminating inheritance, virtual functions, and abstract contracts, Core Solidity relies entirely on traits and modules. In this paradigm, reusable modules own their internal storage and export standard functions. Developers can explicitly wrap and expose only the necessary functions required for a contract’s external interface. Auditors note that this explicit wrapping significantly simplifies the process of reviewing a contract’s exposed surface area, reducing hidden control flows often introduced by complex inheritance hierarchies. While a few development teams remain cautious about transitioning away from familiar inheritance patterns, the overwhelmingly positive reception has guided the creation of extensive multi-module composition examples.

Tooling and ecosystem integration represent another critical area of discussion. Maintainers of static analysis tools and syntax-tree parsers anticipate straightforward integration paths, though analyzers reasoning deeply about complex types will require updates. Regarding broader adoption, the community maintains a characteristically conservative stance, emphasizing that production projects will evaluate Core Solidity only after comprehensive documentation, mature tooling, and thorough security audits are established.

Open questions remain regarding bidirectional ABI compatibility and the ultimate scope of the standard library. While Core Solidity is designed to call Classic Solidity contracts externally, supporting algebraic data types within the standard ABI specification presents ongoing design challenges. Similarly, the developer community remains divided on whether the standard library should remain minimal or expand to include a wider array of utilities.

Looking ahead, the team is actively scoping an initial installable release of the prototype to gather broader community feedback. Documentation updates, deeper dives into non-inheritance composition, and community governance processes for the standard library are slated for upcoming development cycles. The project will also be heavily featured at upcoming global events, including a dedicated presentation at the DeFi Security Summit and a hands-on workshop at Devcon in Mumbai, offering developers direct opportunities to interact with the core contributors and experience Core Solidity firsthand.