Development on Core Solidity—the ambitious new frontend for the solc compiler—is progressing rapidly, with maintainers issuing a comprehensive status update reflecting the state of the project as of early October 2026. Designed to bring advanced programming language features to the Ethereum ecosystem, Core Solidity introduces algebraic data types, pattern matching, generics, traits, and compile-time evaluation while shifting much of the compiler’s built-in machinery into a standard library written in the language itself.
Despite persistent misconceptions in the developer community, project maintainers emphasize that Core Solidity is not a ground-up replacement for the entire compilation pipeline. The backend remains firmly intact: Core Solidity compiles down to Yul, and from Yul onward, bytecode production is handled by the established optimizer and code generator that solc already utilizes for Classic Solidity. The working prototype compiler successfully emits Yul code and feeds it directly into solc, demonstrating seamless integration with the existing infrastructure.
The core engineering team initially introduced Core Solidity in late 2025 through a series of foundational blog posts, detailing its design principles and deep-dive technical mechanics, followed by an exploration of pattern matching earlier in 2026. However, as development advanced through the summer, the language syntax underwent significant revisions to align more closely with developer expectations. Today, code structures look remarkably similar to Classic Solidity, easing the transition for smart contract engineers while incorporating modern language ergonomics.
Current State of the Language
Recent architectural refinements have brought the syntax much closer to traditional Solidity paradigms. Code samples featured in earlier technical write-ups now utilize a provisional syntax and require updates to compile, but the underlying concepts remain entirely consistent. A prominent feature of the updated language is the use of postfix types, where variable names precede their types, such as phase: Phase and amount: uint256. Furthermore, the scope is strictly controlled: aside from a minimal set of built-in types, nothing is available unless explicitly imported, including the standard library itself.
Algebraic data types are vividly demonstrated through enhanced enum structures capable of carrying data, as seen in state-machine implementations like decentralized escrow contracts. In these examples, the match construct dispatches control flow based on the current phase of the contract, and the compiler automatically rejects any match statement that leaves cases unhandled without a designated default arm. Essential utilities reside within standard modules: std supplies fundamental types and basic functions like revertWithError, std.dispatch governs public function execution logic, and std.Generic alongside std.StorageGeneric empower algebraic data types to persist securely within contract storage.
While the prototype remains functional for experimentation, current implementations display minor rough edges. Custom errors are not yet supported, meaning revert operations rely on plain strings, and the compiler currently requires an unreachable return statement following a revertWithError call—an active topic tracked in the project’s open issue logs. Value transfer and access control logic are typically omitted from introductory examples for brevity, but full interactive testing is available via the online project playground.
The prototype compiler hosted within the main solcore repository has successfully undergone rigorous testing against real-world smart contracts. Continuous integration pipelines regularly compile ports of the official Ethereum deposit contract, WETH9, and a minimal ERC20 token, validating them directly through solc and executing them successfully on the Ethereum Virtual Machine. Although events are temporarily omitted from these ports due to current prototype limitations, the test suite proves the viability of the architecture.
For immediate experimentation, developers can utilize the online playground to compile contracts, inspect generated bytecode, call functions, and share stateful links. Advanced playground showcases include multi-vault systems sharing an engine module and token architectures built entirely from feature modular extensions. Meanwhile, formal verification efforts are underway in parallel, with developers formalizing the semantics of Core Solidity inside the Lean 4 proof assistant through a dedicated auxiliary repository.
What Is Still Missing
As an active prototype, Core Solidity lacks several production-grade features relied upon by mainstream decentralized applications. The engineering team stresses that the temporary absence of these features from the current main branch does not mean they are permanently excluded from the language roadmap. Code contributions and pull requests continue to land on a weekly basis, rapidly transforming the codebase.
Gas optimization and bytecode size minimization have not been primary focal points during the prototype phase, meaning formal benchmarks comparing Core Solidity against Classic Solidity are yet to be conducted. Furthermore, Core Solidity takes a deliberate architectural divergence from its predecessor by completely omitting inheritance. Features like virtual functions, abstract contracts, and Classic-style libraries are entirely absent, replaced instead by a robust system of composition through traits and modular imports.
Comprehensive reference documentation is currently available, though it is primarily tailored toward compiler and tooling developers interested in the underlying syntax, type system, and module architecture. Documentation geared specifically toward smart contract application developers remains largely unwritten as the language specification stabilizes.
Community Feedback and Qualitative Interviews
Since March 2026, the development team has conducted 18 qualitative interviews with various industry stakeholders, including protocol architects, security auditors, programming language researchers, educators, tool maintainers, and wallet engineers. These sessions frequently involved participants examining Core Solidity code in the playground for the first time and sharing their immediate impressions.
Algebraic data types and exhaustive pattern matching received overwhelmingly positive reviews across the board. Reviewers frequently highlighted the compiler’s strictness in rejecting unhandled match cases as a powerful safeguard against bugs. Furthermore, security researchers and auditors praised the composition model. By requiring module functions to be explicitly wrapped in public functions to expose them externally, auditors can easily map out the precise attack surface of a contract—a task that is often complicated by deep inheritance hierarchies in Classic Solidity.
Nevertheless, some engineering teams expressed a desire to see larger, real-world deployment patterns replicated via composition before committing to a final verdict. Questions regarding state ownership in reusable modules without direct manipulation of raw storage slots remain a focal point of ongoing discussion. In response to community requests, maintainers have actively expanded the playground with sophisticated composition and reentrancy examples, though current implementations still rely on ERC-7201 namespaced storage slots without native compiler-level safeguards against slot collisions.
Tooling maintainers interviewed during the process noted that adapting static analysis tools and parsers for Core Solidity should require modest effort, particularly for tools operating directly on syntax trees or compiled bytecode. Type-aware analyzers will require more substantial updates depending on final specification decisions. Meanwhile, enterprise adoption discussions revealed a cautious consensus: established projects intend to evaluate Core Solidity with the same conservative rigor applied to any major compiler upgrade, waiting for mature tooling, comprehensive documentation, and thorough security audits.
Open questions remain concerning ABI compatibility and the ultimate scope of the standard library. While Core Solidity is engineered to interface seamlessly with Classic Solidity contracts through a shared ABI specification, bidirectional compatibility poses unique challenges. Specifically, algebraic data types within external interfaces require custom encoding schemes not currently defined in standard ABI specifications, making it difficult for Classic Solidity contracts to invoke certain Core Solidity interfaces without intermediate handling. Opinions on standard library scope varied widely between minimalists advocating for a lean base and those favoring a comprehensive out-of-the-box toolkit.
What Changes and Next Steps
Insights gathered from community interviews have already catalyzed concrete improvements within the repository, clarifying the fundamental distinction between the new frontend and the existing backend. Maintainers have recognized documentation and compilation speed as critical user pain points. While the prototype’s custom frontend has not yet been heavily optimized for speed, the shared backend benefits directly from ongoing performance improvements such as the experimental SSA CFG code generator introduced in recent Classic Solidity releases.
Looking ahead, the team is actively scoping an official, installable preview release of the prototype to facilitate broader community testing and gather early feedback, though no definitive launch date has been announced. A dedicated deep dive exploring contract composition without inheritance is scheduled for publication shortly, alongside the formalization of community contribution workflows for the standard library.
The development team will present updates on Core Solidity at upcoming industry events in Mumbai, including a technical talk at the DeFi Security Summit and a hands-on smart contract workshop at Devcon. Qualitative interviews with developers, educators, and auditors remain ongoing, and interested contributors are encouraged to reach out to the core team via their official project communication channels, participate in weekly open team calls, or review build instructions available directly within the main repository.






