DSS

DSS 2026 / Day 2 / Pearl Hall

What you need to know about Core Solidity

Jacob Czepluch

15:17 · Recording

Watch on YouTube ↗Open recording viewerOriginal programme entry
Download plain textDownload timestamped JSON

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:05a

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

Source export SHA256: b136e47da787218c0b30c5c41ad88f996c8ed956bfe24edaaca33d4778e636f8