@sebastiengllmt.bsky.social
Co-founder of @PaimaStudios / @dcspark_io Focus: game development & cryptography
Recently thinking that maybe game engines should ship default terminal multiplexer configs
Lots of times running the engine requires setting up multiple terminal window and it would be nice to have some pre-configured
Experimenting with this idea for our engine
These projects continue to evolve over time
Mina working to solve the data issue in very clever ways (future thread/video)
Midnight has some interesting R&D on function composition
So I'm excited to see both continue to grow!
So both Mina and Midnight provide similar functionality
But they implement it very different ways, both with trade-offs!
They're both cleverly engineered, which is why we've followed both of them closely π
Midnight, by thinking of data & variables as the primitive (instead of function composition), makes it easy to write data-heavy apps!
You can build
- games (secret information)
- RWAs (only reveal regulatory-relevant info)
- DeFi (don't reveal your position right away)
and more
When a user wants to update the public state, they
β don't reveal their private state
β
do prove something happened in their private state to allow them to update the public state
ex: prove you did something to earn 50 points (not revealing it's because you built a building)
For example, you can represent a strategy game as some small amount of public information (ex: points, etc.)
And players have some private state (their position in the map, how much gold they have, etc.)
(3) Midnight
Midnight, instead, keeps track of a public chain (a bit more similar to Bitcoin)
However, each user in Midnight has their own private state that is never shared with the rest of the blockchain
Need data? You need to fetch it from elsewhere (ex: somebody whose node kept a backup)
You can still prove the data somebody gives you is correct (since you know the latest block, aka what the end result should be)
but it makes data-heavy dApps on Mina bit hard to build
However, I skipped an important part: what happens to the data of smart contracts?
Unlike public blockchains, the data is not kept around in the blocks! Everything just gets compressed into a proof
So in Mina, by just a very simple concept of modelling ZK proofs of "functions" that you can "compose"
we automatically are able to build this super succinct blockchain like we wanted!
Transactions are combining proofs of multiple functions
Blocks are just combining proofs of multiple txs
A blockchain is just combining proofs of multiple blocks!
Note that functions can call other functions (function "composition")
In our example, to prove "foo", we need to prove "bar" first
but remember: we know how to combine proofs together! So combining the proof of "bar" into a proof of "foo" is easy!
But how do we generate ZK proofs of smart contracts?
Well, you can think of smart contracts as a list of functions
So all we really need is a way to generate "proofs" of a function (which, fortunately, is a very well studied problem with known solutions)
As we saw earlier, we can combine proofs
So this means we can now combine everything into just a single proof of the genesis block to the latest block!
(2) Mina
Similar to how we "proved Waldo exists", what if we instead "prove" there exists a block transitions
AKA, given block A, prove there exists some set of transactions that give you block B as a result
Now, ever transition is a ZK proof
(1) Regular chains
If you want to know the state of Bitcoin, you often need to sync the full Bitcoin blockchain to get full security
However, this takes a lot of space on your device which isn't ideal. It's worse on chains like Ethereum, and even worse on Solana
We'll explain how Mina & Midnight use these in three steps:
1. How do regular chains work
2. How does Mina work
3. How does Midnight work
Mina & Midnight both use a technique called "recursive SNARKs" that allows you to combine proofs together
Conceptually, you can think of revealing you know the location of multiple Waldos across different pages at the same time
This gives you a way to show two things:
1. Privacy: you know where Waldo is (without revealing to your friend, as they can't see the rest of the book other than your small hole)
2. Compression: You've proven Waldo exists by only showing a small amount of info (a small hole)
To show both are possible, imagine a "Where's Waldo" game
How to prove to your friend you found Waldo without spoiling the game for them?
Answer: Cover the entire book with a big sheet of paper, and cut a small hole exactly where Waldo is
"ZK" stands for "Zero Knowledge Cryptography". It's a technique that gives you at least one of two things:
- Private computation (required for RWA, gaming, some DeFi apps)
- Massive compression (useful for L2s, bridges, data-heavy use-cases)
Midnight & Mina give both
You've probably heard about Midnight and Mina multiple times
But what are they? How do they give privacy? How can they connect to other chains? Why are they exciting?
I cover it all in my latest video + thread β
www.youtube.com/watch?v=3vW-...
every time I find a project I'd be interested in leveraging
> please don't be written in some bs language
> please don't be written in some bs language
> please don't be written in some bs language
the project's Github page
Made my first PR to @opentelemetry.io !
github.com/open-telemet...
Used this to build a Javascript-based log collector so that you don't need to run a docker contain just to aggregate logs on dev builds
It was super fun to learn about color theory, and very satisfying that it tied multiple fields of math together with delightfully surprising results
Hope you enjoyed reading this as much as I enjoyed writing it!
I've published the Javascript code to generate colors like this yourself for your own tools entirely free and open source! (on both NPM & JSR)
www.npmjs.com/package/mate...
This means that every color generated by our tool can also be used to generate a great Material Design color scheme !
This makes it super easy to have not just one color per system in your app,
But even generate colorful dashboards and subcomponents that feel color-aligned!
Material Design has a recommendation for which color to use to create your color palette: its saturation should be above "48"
and for brightness 68,69,70
no matter which color you pick, there exists a choice with saturation above 48π€―
In fact, brightness levels 68, 69 and 70 are the only brightness levels with a special property!
Many Anrdoid apps and websites use a design system called material design created by Google
It allows creating beautiful color schemes for your app on a color (ex: your brand color)
Great! So now we know which brightness to pick!
and it gives us these beautiful colors, all while having a consistent brightness!
