DSS 2026 / Day 2 / Pearl Hall
What you need to know about Core Solidity
Jacob Czepluch
Source: YouTube automatic caption track · Exported 2026-11-16. Timestamps link to the source video. Cue end times were not supplied.
Transcript
0:00All right.
0:01Hello, everyone.
0:03Thank you for being here. I was supposed
0:05to present this morning at 10:00, but I
0:07thought it was 10:15, so
0:09I didn't present this morning.
0:11And now I'm trying to present instead.
0:14So I will talk a little bit about
0:17what you need to know
0:18about core solidity from a security
0:20perspective.
0:23So yeah, I'll walk you through that. We
0:25don't have that much time, but
0:27let's
0:28see if we can get some useful
0:29information through.
0:31A little bit about myself. I wrote my
0:33first smart contract back in 2015 when I
0:36wrote my bachelor thesis about Ethereum.
0:39This is some of the code from back then.
0:42It looks pretty familiar, I think, but
0:44with some differences, of course.
0:46Since then, I've also been doing an
0:48internship at the Ethereum Foundation in
0:492015 working on the Python client that
0:52actually used to exist back then.
0:54Then I worked for 6 years on the Raiden
0:56network, which was payment channels, 10
0:59years too early, as so many things were
1:00back then.
1:02Then I've been doing hack prevention
1:03tools at Firefly Systems, and now I'm
1:05the solidity developer relations at the
1:07Agro Collective.
1:10So if you take five things away from
1:12this talk, it should be that core
1:14solidity is a new front end for Sol C.
1:18So basically from Yul onwards, it's the
1:20same pipeline.
1:23We have or the language will have enums
1:25that carry data, so algebraic data types
1:28and
1:29pattern matching.
1:31So basically whenever you have
1:34like
1:35a case that is that doesn't have a
1:37match, then you simply don't compile. So
1:39this catches a whole
1:40category of of of box in the compiler.
1:45Modules choose what they export, so you
1:48will have to be explicit about what your
1:50contracts are
1:53basically
1:54exposing.
1:57There'll be no inheritance, so I this is
1:59a controversial one,
2:01um but also something that has been the
2:04pain uh and the cause of a lot of
2:06issues.
2:07Um and it will be replaced by something
2:09like traits in in in in Rust. Uh we're
2:12still
2:13There's some different ways of doing it
2:14and uh yeah, we're experiencing a lot.
2:16Um and we will have a standard library,
2:18which I think is also a great thing that
2:20a lot of people have been asking about
2:21since
2:23day one. Um and that means that we're um
2:26basically separating language from the
2:28compiler so we can add features to the
2:31language without having to release a new
2:32version of the compiler.
2:35Um and where are we today with this? Um
2:39still a prototype, of course. Uh
2:41please do not uh deploy contracts to
2:43mainnet with it.
2:45Um we're still changing the language a
2:47lot. There will definitely be a breaking
2:49changes moving forward still.
2:52We have uh
2:54browser playground that um yeah, you can
2:56compile, deploy uh
2:58to testnets, call the contracts, um
3:02view the bytecode, stuff like that. So
3:04you can basically play around with the
3:05language already.
3:07Um
3:08we've ported a bunch ported a bunch of
3:10contracts um
3:12so just to to to ensure that it actually
3:15works. And we are also currently working
3:18on uh a lean four model
3:20uh of the semantics of the language. Um
3:24and we also doing like
3:26like like um semantics of the API
3:28encoding and we found a couple of bugs
3:31uh through this already.
3:33Um and yeah, as I mentioned, we have uh
3:36like it's a prototype, but we did just
3:37make the first alpha release uh last
3:40week. So you can actually
3:42uh download it and run it on on on Linux
3:44and Mac and it has a formatter, a
3:46language server, and plugins for um the
3:49most uh
3:50popular um editors.
3:54We've also since the beginning of summer
3:56been conducting uh around 20 interviews
4:00with a lot of different people from the
4:01ecosystem ranging from auditors,
4:04protocols,
4:06library developers, tooling,
4:09and wallets.
4:11And we've basically collected feedback
4:13on
4:14classic Solidity, but also core and and
4:16and introduced it to to a bunch of these
4:18people. And some of the the feedback we
4:20got was that these enums that carry data
4:23is
4:25something people really like.
4:28Almost everyone was like getting it
4:29right away and thought that it was a a
4:31very welcome change or introduction
4:34to the language.
4:36A lot of the auditors we talked to were
4:37also quite happy to see that you now
4:39have to be explicit about what a
4:41contract is exposing. So in the past, if
4:44you did inheritance, you could inherit
4:46like several layers deep and your
4:49contract would expose public functions
4:51from
4:51from all of this.
4:53And now you have to be explicit about
4:54what a contract contract exposes, which
4:57will also make the lives of auditors
4:59quite a lot easier, I think.
5:03As I mentioned, removing inheritance is
5:05is one of the let's say main concerns
5:08for some of the projects that
5:10have relied heavily on inheritance for
5:13for many years. And they are, of course,
5:16a little bit skeptical about how how
5:18should their contracts look
5:21without this.
5:23I totally understand that, and I don't
5:24expect from the get-go that
5:29very well-established protocols are just
5:31porting their entire code base over.
5:34It will definitely be a a long
5:37adoption, and it's probably more going
5:38to be new projects that will be writing
5:40core Solidity, and
5:42older projects will will stick to to
5:44classic. And we will also continue to
5:46maintain classic Solidity. It's not like
5:48we're abandoning it.
5:50I'll talk a little bit about more about
5:52that later.
5:53And another interesting point was, as
5:55you probably most agree with, that
5:59most people think that AI will be
6:00writing
6:01most of the code in the future, and
6:03humans will mostly review it.
6:06Um and for that reason, explicit uh code
6:10uh is better. Um and
6:13so we can have more like explicitness in
6:15the language itself. And uh same with
6:17like precise errors.
6:20Um these interviews also meant that we
6:22already changed some things in both the
6:24approach we we took to to Core Solidity
6:26and also in some of the the features. So
6:29from these interviews, people had
6:30questions regarding like some of the
6:32examples we had and like how we would
6:35show or do a specific thing um which has
6:37then meant that we've been developing
6:39examples for this that we've shared and
6:41gotten a lot of good feedback from and
6:43some people already
6:44uh opened pull requests or issues with
6:46uh with things they found after trying
6:48it out. Um
6:50so yeah, the the the interview is
6:52already shaped kind of the the future of
6:53the language. And whenever we have
6:55design calls, I take the feedback and
6:57and kind of represent the community as
7:00well in in these calls. So so we have a
7:02good process going for this um which I
7:05think is is quite nice because it's
7:07important that we design a language that
7:09users actually want to use and not just
7:10one that uh we think is uh interesting
7:13to to make.
7:15So that's uh
7:16moving in the right direction.
7:19So more into to to the language. As I
7:21mentioned, it's a new front end for the
7:23SolC back end. So from basically
7:25lowering to to um to Yul, the pipeline
7:28is the same. This also means that all
7:30tools that currently work on bytecode
7:32will will not uh have to to change
7:34anything per se.
7:36Uh the tools that rely on the exported
7:38uh AST, they will need to do some uh
7:41adjustment because the the AST will will
7:43look different.
7:45Um and then the the work we're currently
7:47doing on the new pipeline uh is the ACFG
7:51um like in the back end um will benefit
7:54um both classic and Core of course
7:57because it will be the the same pipe uh
7:59pipeline that it goes through. And for
8:01those who don't know, ACFG is a new
8:03pipeline that fixes stack too deep um
8:06but will also allow for a lot nice
8:08optimizations, both in terms of like
8:11tooling, but more more importantly in
8:13compile time, which is some of the
8:15things we've got the most
8:19the most
8:21the most
8:22criticism for, of course. Yeah, so why
8:25why a new front end? Like why not
8:28change classic Solidity to cover all
8:30these things?
8:33Classic Solidity has quite a lot of
8:35years, like 11 years now, and almost
8:37every time there's a new feature, it's
8:39more added as a patch than actually
8:41designed in a in a good way.
8:44So like yeah, it's pretty hard to
8:46maintain the compiler by now, and like
8:48one example is try catch, which you all
8:49probably know about, and it's like not
8:51the most pleasant thing to to work with.
8:54And there's no formal specification, and
8:56if we were to write one, it would mean
8:57that documenting how every single
8:59feature interacts with each other, which
9:01is just a crazy task.
9:04So the motivation would be to say, okay,
9:07what if we start over? What if we design
9:09a language from the ground up that
9:10actually makes sense
9:12for what a smart contract language
9:14should look like in 2026 or like then
9:172024?
9:18So Core has a small set of primitive
9:21primitives in like a lower language,
9:24eight primitives and one type, which
9:26makes it possible to yeah, formally
9:28verified, for example.
9:31Which we we are working on.
9:33And I'm just jumping ahead because I'm
9:34running out of time. But yeah, we also
9:36have a bunch of new features like
9:37generics, traits, enums as I mentioned,
9:39pattern matching, and we'll have
9:42standard library.
9:44I'll skip this slide.
9:46It's just comparing some of the
9:48differences, but it's not that
9:49important.
9:51A couple of code examples. So
9:54most of you probably know how pattern
9:55matching works, but in this case, in
9:57this example, we are not covering the
10:00stale
10:01case, which means that the compiler
10:03catches this error and tells you right
10:04away you you're not handling this
10:06specific case.
10:08So you kind of
10:09compiler makes sure that you always have
10:11coverage for all
10:13possibilities of of a of a of an enum.
10:17Unless you have like a catch-all
10:19arm, which in that case it will still
10:22allow it, but
10:24still better.
10:26Then we have something like
10:29like in the modules as I mentioned. So
10:31this module doesn't have a contract. It
10:33just exposes the the functions. And in
10:35this case we can construct all pools
10:39in a function in this module
10:41and run a require on it. So basically
10:43check for an invariant. And the only
10:45place that is can make a new pool is in
10:47this module. So outside of pool, that's
10:51all,
10:52we cannot construct pools or we cannot
10:54read its fields either. So this kind of
10:56gives you a one place only where you can
10:59do all these checks and do all these
11:00invariant checks. You don't have to do
11:01it in every single function that updates
11:04a value, which I think is is is pretty
11:07neat as well.
11:10As I mentioned, modules replace
11:12inheritance. In this example we have
11:15possible. This is like a a token simple
11:18token example where we have possible
11:20that is then
11:21exposing the functions that it it wants
11:23to
11:24pose. And then we import it in the token
11:26contract where we can then
11:29use possible. So in
11:31those of you who know the Open Zeppelin
11:33ERC 20, they have all these extensions
11:35that you can import. And here we do it
11:38like this instead of through
11:41inheritance.
11:46Yeah, we'll have the the standard
11:47library, which I think is
11:49really great thing to to have in a in
11:52the language because we can actually
11:54make changes to the language without
11:56also having a release of the compiler.
11:59This is an example for how add is
12:02implemented on
12:04U and 256. And as you can see U and 256
12:06is word, which is the
12:08the base type of this lower language.
12:11And a lot of things are being
12:12implemented in the standard library. One
12:15of the the people who are helping out in
12:17the project um
12:18used to work in Solidity in the early
12:20days and he said that he implemented
12:22some of the the things in the standard
12:24library in an afternoon and it used to
12:26take them three months when they did it
12:28in the in
12:30SolC back in 2017 or something like
12:32that. So I think that shows some of the
12:34the
12:35the power that we can get out of uh a
12:37language that has a a standard library.
12:44So we still have some uh open design
12:46questions of course. It's still early
12:48days um but
12:50uh we appreciate feedback on on all of
12:52these of course. Some of them are
12:54bigger, some of them are smaller. Um but
12:56if you ever check out the language and
12:58you run into something you don't
12:59understand or that it's weird or ideas
13:01for what to improve then don't hesitate
13:03to to open uh
13:05uh an issue. Um currently what we have
13:07open is like storage and upgrades uh
13:10like state owned modules as I mentioned.
13:13They are control enum values that stay
13:15valid when a variant is is added,
13:17proxies. Um so there's still
13:19a lot of things we that we need to
13:21figure out. Then one of the bigger
13:23things is like or bigger things but one
13:25thing that will matter a lot I think is
13:26initialization of state.
13:28So right now as you all know in in in
13:30classic Solidity if you initialize a
13:32value it will have the basically the
13:33zero value of of that uh
13:36that um type which can be somewhat uh
13:40confusing and we are currently
13:41discussing if we should have implicit
13:43type uh like so you cannot initiate a a
13:46value without also assigning uh a value
13:48specifically to it and that will
13:51uh
13:52be quite a nice thing but it will also
13:53break with a lot of the ways people
13:56think about Solidity in general. So this
13:57is something we're very happy to get
13:59feedback on. You can check the the issue
14:01out.
14:02Um another thing is like forward and
14:04backward compatibility. Um so
14:07of course we have to have backwards
14:09compatibility but how do we do forward
14:10compatibility? For example with pattern
14:12like the the pattern matching how do we
14:14do that in in like classic doesn't know
14:16the API that you need to do that. So,
14:19how should we handle this? Should we
14:21like add it to the API or like so that
14:24it classic, Viper, etc. will also
14:26support it or should we just move ahead
14:28and
14:29see what like so we're not held back
14:32basically.
14:34Um and then yeah the the scope of the
14:36standard library is also an open
14:38question.
14:39Um like should it be basic small as
14:41possible or should we add
14:43like batteries included basically.
14:46I'm running out of time so
14:47that's that's good. But yeah give it a
14:49try. As I said we have the prototype
14:51release you can download the binary
14:54and we also have the playground.
14:56On Thursday at 12:00 I'm giving a
14:58workshop on Core Solidity hands-on how
15:01to write your first smart contracts.
15:04And if you're interested in also getting
15:06small intro or do one of these
15:07interviews I talked about find me after
15:10or write an email.
15:11Um yeah that's all I'm out of time.
15:14Thank you very much.
Source and accuracy details
- Names, organizations, technical terms, code and numbers may be misrecognized.
- Source wording and disfluencies are preserved; no editorial corrections were applied.
- Export contains whole-second cue starts only; cue ends and subsecond timing are unavailable.
- A full caption-track export does not establish that every spoken word is represented.
- Automatic YouTube captions; not human-verified against the audio.
Source export SHA256: b136e47da787218c0b30c5c41ad88f996c8ed956bfe24edaaca33d4778e636f8