The development team behind Solidity has released a comprehensive status update on Core Solidity, introducing significant syntax refinements, community interview insights, and a clear roadmap for the cutting-edge language frontend. Reflecting the state of the project as of early October 2026, the report emphasizes that while Core Solidity introduces advanced functional programming paradigms—such as algebraic data types, pattern matching, generics, traits, and compile-time evaluation—it remains strictly a prototype unsuitable for mainnet deployment.
Core Solidity functions as a modern frontend for the established solc compiler. Rather than overhauling the entire compilation pipeline, the architecture retains the proven backend: Core Solidity compiles down to Yul, and from that intermediate language onward, bytecode is produced using the exact same optimizer and code generator that solc relies on for Classic Solidity today. The prototype compiler already operates in this exact manner, successfully emitting Yul and handing it over to the traditional compiler pipeline. Developers have occasionally expressed concern that Core Solidity might completely replace the existing compiler infrastructure, but the team continues to clarify that the backend remains entirely unchanged.
Current State of the Language
Over the summer, the development team heavily reworked the syntax to bridge the gap with Classic Solidity, making the language feel immediately familiar to existing smart contract developers. Code samples from earlier design posts use a provisional syntax and no longer compile, but the underlying architectural concepts remain fully intact.
The most notable visual differences include postfix types, where types follow variable names rather than preceding them, as seen in declarations like phase: Phase and amount: uint256. Furthermore, scopes are now strictly isolated; nothing beyond a small set of built-in types is available unless explicitly imported. This requirement extends to the standard library itself.
Through these updates, an enum variant can now carry data, allowing definitions like an escrow lifecycle Phase to serve as fully realized algebraic data types. The standard library provides basic primitives such as uint256 and revertWithError, while modules like std.dispatch handle public function routing, and std.Generic alongside std.StorageGeneric enable complex algebraic types to reside natively in contract storage. Because the generated dispatch and storage code relies on these specific names, current implementations require wildcard imports.
Pattern matching via the match construct deconstructs these algebraic data types safely. The compiler enforces exhaustiveness, automatically rejecting any match statement that leaves a case unhandled without providing a default arm. While the prototype demonstrates immense promise—with test suites successfully compiling ports of the Ethereum deposit contract, WETH9, and a minimal ERC20 token through solc and executing them on the Ethereum Virtual Machine—rough edges remain. Custom errors are not yet supported, forcing reverts to carry plain strings, and certain control flows currently require a redundant return statement following an error revert.
What Is Still Missing
Despite robust progress visible on the main branch of the solcore repository, several production-critical features are still absent from the prototype. The missing components span multiple categories, though active pull requests are frequently opened and merged by the community and core maintainers on a weekly basis.
While features like structs exist within the repository source code, they have not yet propagated to the interactive online playground. Gas costs and optimized code size have not been primary focus areas for the prototype phase, meaning rigorous performance comparisons against Classic Solidity have yet to be conducted.
Significantly, Core Solidity deliberately abandons traditional inheritance models. There are no virtual functions, no abstract contracts, and no Classic-style libraries. Instead, code reuse and architecture rely entirely on composition through traits and feature modules. Modules maintain their own storage and export ordinary functions, allowing developers to wrap specific internal behaviors into public contract interfaces selectively. Security researchers and auditors interviewed by the team have responded positively to this shift, noting that eliminating inheritance substantially simplifies the process of reviewing an exposed contract attack surface.
Community Feedback and Qualitative Interviews
Since March 2026, the Core Solidity team has conducted 18 qualitative interviews with protocol developers, security auditors, educators, tool maintainers, wallet teams, and language researchers. Most participants reviewed Core Solidity code in the playground for the first time during these sessions, providing invaluable feedback that directly influenced subsequent compiler adjustments and language design choices.
Algebraic data types and pattern matching received overwhelming praise, with reviewers repeatedly highlighting the safety benefits of compiler-enforced match exhaustiveness. Most participants found the syntax intuitive and remarkably close to traditional Solidity.
Regarding the removal of inheritance, most interviewed experts expressed comfort with the change, with auditors confirming that deep inheritance hierarchies frequently hinder security reviews. However, a small subset of development teams relying heavily on specific legacy inheritance patterns noted they need to see complex, real-world examples of composition before making a final judgment. In response, the team has expanded its repository of composition and extension examples to demonstrate how modules can manage state cleanly without dealing directly with raw storage slots.
Tooling maintainers anticipate relatively minor friction when adapting static analysis and parsing tools to support the new syntax, though type-aware analyzers will require deeper updates depending on the finalized type system. Meanwhile, established enterprise projects indicated they would approach Core Solidity with the same conservative caution applied to any major compiler upgrade—waiting for battle-tested reliability, complete tooling, and thorough auditing standards.
Open Questions and Future Outlook
Two major architectural questions remain under active debate within the community. The first concerns ABI compatibility. While Core Solidity is designed to utilize the same ABI as Classic Solidity—allowing Core contracts to make external calls to Classic contracts seamlessly—the reverse direction presents hurdles. Because algebraic data types require custom encodings not defined in the current ABI specification, Classic Solidity contracts cannot easily call every Core Solidity interface without additional tooling. While most interviewees considered this a lower priority, some urged the team to maintain bidirectional composability if feasible.
The second open question involves the ideal scope of the standard library. Opinions range from maintaining a minimal footprint to establishing a comprehensive core library that underpins third-party packages. Concerns over bug propagation—where a defect in a centralized standard library impacts all downstream users—continue to guide this delicate balancing act.
As development continues, the team is actively scoping a downloadable initial release of the prototype to gather broader community feedback. Public engagement remains high, driven by weekly open team calls, ongoing documentation efforts, and upcoming presentations at major ecosystem events including the DeFi Security Summit in Mumbai and Devcon. Developers interested in exploring the language can access the online playground, examine the solcore repository for build instructions, or reach out directly to the core team to share feedback and contribute to the future of Solidity.
