By Evan Lee Salim 
The development team behind Solidity has released a comprehensive status update on Core Solidity, offering a detailed look at the prototype language frontend designed to modernize smart contract engineering on the Ethereum Virtual Machine. Reflecting the state of the project as of early October 2026, the report outlines significant syntactic revisions, community feedback gathered through qualitative interviews, ongoing formal verification efforts, and a clear roadmap for upcoming milestones.
Core Solidity functions as an entirely new frontend for solc, the standard Solidity compiler. It introduces a sophisticated type system equipped with algebraic data types, pattern matching, generics, traits, and compile-time evaluation. Furthermore, it shifts a substantial portion of the compiler’s built-in logic into a standard library written natively in the language itself. Despite these advanced features, the underlying compilation pipeline remains fundamentally unchanged: Core Solidity compiles down to Yul, and from that point onward, bytecode production is handled by the identical optimizer and code generator that solc utilizes for Classic Solidity. The working prototype compiler successfully emits Yul and passes it directly to solc for final processing.
To dispel persistent misconceptions encountered by the development team throughout the year, engineers reiterated that Core Solidity is not intended to replace the entire existing compiler infrastructure. Instead, it builds upon the robust, battle-tested backend that developers have relied upon for years. The language was initially introduced in late 2025 through a series of foundational blog posts detailing its architectural design and pattern-matching capabilities. However, syntax has undergone substantial refinement over the summer months to align more closely with the familiar conventions of Classic Solidity.
Current State of the Language and Syntactic Evolution
The recent syntactic overhaul brings Core Solidity much closer to the expectations of seasoned Solidity developers. Code samples published in earlier architecture posts utilized provisional syntax and no longer compile, although the underlying concepts remain entirely valid. Modern Core Solidity code exhibits structural patterns that developers will immediately recognize, with the most notable visible differences being postfix types—where types follow names, such as phase: Phase and amount: uint256—and a strict scoping rule where virtually nothing beyond a minimal set of built-in types is available unless explicitly imported.
Algebraic data types are prominently featured through advanced enum variants capable of carrying embedded data. For instance, an escrow lifecycle can be modeled cleanly using an enum with states like AwaitingPayment, Funded(uint256), and Released(uint256). The language leverages specialized imports from the standard library namespace, where std provides basic types and error-handling utilities like revertWithError, std.dispatch manages the internal mechanics of public functions, and std.Generic alongside std.StorageGeneric enables complex algebraic data types to reside natively within storage slots.
Pattern matching serves as a primary control-flow mechanism, neatly deconstructing algebraic data types. The compiler strictly enforces safety by rejecting any match statement that leaves a variant case unhandled without an explicit default arm. While the prototype currently requires minor workarounds—such as inserting an unreachable return statement after a revert—and relies on plain string errors prior to the implementation of custom errors, its core functionality has been rigorously tested. The development team maintains a test suite within the solcore repository that successfully compiles ports of foundational Ethereum infrastructure, including the official Ethereum deposit contract, WETH9, and a minimal ERC20 token, executing them directly against the EVM in continuous integration pipelines.
For developers seeking hands-on experience, an interactive playground is currently available. It allows users to compile contracts, execute function calls, inspect generated bytecode, and share specific workspace views. Beyond basic examples, the playground features sophisticated architectures such as multi-vault composition over a shared engine module and modular ERC20-style tokens built entirely from feature components. Additionally, the development team is formally verifying the semantics of Core Solidity using the Lean 4 proof assistant within a dedicated repository, with further results expected as the formalization progresses.
What is Still Missing and Deliberate Architectural Differences
While the prototype compiler on the main branch of the solcore repository advances rapidly with weekly pull requests and code merges, several production-grade features are still under development. Gas optimization and code size reduction have not yet been primary focal points for the prototype, meaning formal gas and efficiency comparisons with Classic Solidity remain unconducted. Work is ongoing for numerous standard features, while others are intentionally omitted to embrace a cleaner paradigm.
Most notably, Core Solidity completely abandons traditional object-oriented inheritance. There are no virtual keywords, no abstract contracts, and no Classic-style inheritance structures. They are entirely superseded by modern composition through traits and modular libraries. This design choice aims to simplify contract architecture and eliminate the review complications frequently associated with deep inheritance trees. Furthermore, work-in-progress reference documentation currently caters primarily to compiler and tool developers, leaving comprehensive guides for contract developers scheduled for later phases of the project.
Community Insights and Qualitative Interviews
Beginning in March 2026, the core team conducted 18 in-depth qualitative interviews with protocol developers, security auditors, educators, library and tool maintainers, wallet developers, and programming language researchers. Participants reviewed Core Solidity code directly within the playground, providing vital feedback on ergonomics and architectural philosophy.
Algebraic data types and pattern matching received overwhelming praise, with reviewers repeatedly highlighting the safety benefits of compiler-enforced exhaustive pattern matching. Most participants without prior preparation could read and comprehend Core Solidity contracts easily, confirming that the syntax successfully retains a familiar Solidity aesthetic. Auditors and security researchers expressed strong approval for the modular composition model, noting that explicit function wrapping and modular storage ownership significantly streamline the process of identifying an exposed public attack surface.
Discussions surrounding ABI compatibility revealed nuanced perspectives. While Core Solidity is architected to utilize the standard ABI—allowing Core contracts to make external calls to any Classic Solidity contract—the reverse direction remains an open challenge. Complex algebraic data types residing in external interfaces require encoding standards that the current ABI specification does not accommodate, meaning Classic contracts cannot natively invoke every Core Solidity interface without intermediary handling. While most interviewees categorized this capability as a lower priority, some advocated for maintaining complete bidirectional interoperability to ensure seamless ecosystem integration.
Regarding standard library scope, opinions spanned from minimalist approaches to comprehensive frameworks. Proponents of a lean standard library emphasized that minimizing built-in code reduces the surface area for latent bugs, whereas others favored a richer foundational layer. Meanwhile, developers identified persistent pain points in Classic Solidity—such as the EVM contract size limit, compilation latency, and stack-too-deep errors—reinforcing the value of the experimental SSA CFG code generator embedded in the shared backend. Moreover, as automated coding assistants become increasingly prevalent in smart contract creation, participants noted that Core Solidity’s explicit, readable structure and precise compiler error reporting provide critical advantages for AI-generated code.
Future Outlook and Community Engagement
As the project looks toward upcoming development cycles, the engineering team is actively scoping an initial installable release of the prototype to facilitate broader community testing and early adoption feedback. Documentation for contract developers remains a top priority for upcoming milestones, alongside published deep dives into inheritance-free composition and the formalization of community contribution workflows for the standard library.
The engineering team continues to engage directly with the global developer community. Core contributors will present updates at upcoming industry gatherings, including a dedicated presentation at the DeFi Security Summit in Mumbai and a hands-on workshop at Devcon for developers looking to build their first Core Solidity smart contract. Qualitative interviews with auditors, educators, and protocol engineers remain ongoing. Developers interested in reviewing the prototype, exploring build instructions, or contributing to the discussion can access the public solcore repository, participate in weekly open team calls, or reach out directly to the core development team.
Nana 
Siti Muinah 
Layla Zulfa