![LatticAwaLLLnut's tweet photo. Caution! this post is about why LatticA is fast, and it does contain a bunch of Fully homomorphic encryption, FHE / lattice-crypto stuffs
Hi! We’re finally able to share one of our core research results.
If you’ve seen our Gitbook, one of the mysterious keywords there was “Primitive Gate”.
Paper is now on ePrint: https://t.co/sY44AoasGD
[For the record, we even pre-committed to the name in the docs: SHA256("Primitive Gate") = f321ce2f5032c6d408f553606755b51378366c99adfa37337c95c1a330577139, see: https://t.co/g0ykztlGeW]
Gate FHE doesn’t do fast SIMD like other schemes.
Instead, it shines in low latency for single operations + small evaluation keys (public-key-like).
Let’s call this style latency-first FHE.
In the early days you could only homomorphically evaluate gates (AND/OR/XOR).
Building integer arithmetic by stacking tons of gates was… painfully inefficient.
To fix that, the community moved toward programmable bootstrapping (PBS) and LUT-based approaches:
You “program” a small lookup table (LUT) and evaluate it homomorphically.
Very much like compiling logic with LUTs on an FPGA.
People tried to increase LUT input bits / output bits to make it more powerful.
But as LUTs got more powerful, we started to lose the “latency-first” advantage.
Evaluation keys exploded in size, to the point where some schemes no longer fit comfortably in a web browser.
(Example: big-key FHE stacks end up needing server-side or heavy environments instead of “runs anywhere” crypto.)
We took a step back and asked:
“Is maximizing LUT power really the right direction for latency-first FHE?
Even if LUTs stay small, is there another axis we can push?”
This led us to define a function class called the
blind rotation function family (BRFF) and explore that space instead.
The “oh wow” moment:
Latency-first FHE should be generalized not by LUTs, but by BRFF.
You don’t have to keep making LUTs bigger – you can widen the function class that BRFF can handle.
We call the resulting function family Primitive Gate.
Very informally, Primitive Gate includes:
The usual gate ops from latency-first FHE:
AND, OR, XOR
Mixed gates like:
AND-XOR, OR-XOR
XOR6: a 6-input XOR
(the “6” is generalizable; FHE16 currently uses up to 6 inputs)
MAJ3(x, y, z) = (x AND y) OR (x AND z) OR (y AND z)
– the 3-input majority function
EQ3(x, y, z) = 1 if (x == y == z), else 0
The key punchline:
All of these run in essentially the same latency as a normal gate,
and we don’t blow up key sizes like in PBS-heavy designs.
No “one op is much slower”, no monstrous evaluation keys.
Also important:
This work does not assume a new cryptographic hardness assumption.
it’s a new fact, so you can treat it as “safe to use” even though the paper is on the archive right now.
So what does this mean for LatticA and FHE16?
FHE16 was already fast.
By exploiting the Primitive Gate capability, LatticA can push further:
Faster than state-of-the-art FHE in our target setting
Smaller key sizes at the same time
That’s the core story behind why LatticA can be both fast and browser-friendly.
Next steps / roadmap
A) We’re not done yet
There are still several research results / papers in the pipeline.
We’ve already left cryptographic “commitments” (hashes) to them in the Gitbook and are excited to reveal them one by one.
B) Most FHE research pours effort into hardware acceleration:
GPU, FPGA, ASIC…
But many blockchain folks we spoke to don’t just want “some vendor’s FHE in their data center”.
They want:
“FHE that runs in my browser, on my phone.”
We think that direction is very cool.
So before we rush to build accelerators, our next concrete goal is:
Put FHE16 in the web browser,
so that users can directly compute on ciphertexts in the front end.
Stay tuned :)
@Isley1249 , @thegimsin , @Scarrots93 , @DJShin73](https://pbs.twimg.com/media/G66KYq4bkAMni3a.png)
Olivia
Online
Dong-Joon Shin
@DJShin73
CSO@waLLLnut | Prof. Hanyang Univ |
waLLLnut's confidential coprocessor for private and transparent RWA transactions |
대한민국 서울
Joined September 2025
39 Following
8 Followers
54 Posts
STANFORD'DA BİLGİSAYARLARI KAPATTIRAN O CÜMLE
Efsanevi yapay zeka profesörü Andrew Ng, Stanford'daki dersine şu sözle başladı ve sınıftaki öğrencilerin yarısı bilgisayarını kapattı:
“Önümüzdeki 10 yılda kazananları kaybedenlerden ayıracak yeteneğin, iyi kod yazmakla hiçbir ilgisi yok.”
Neden mi? Çünkü yapay zeka sayesinde artık herkesin sınırsız bir üretim gücü var. Günümüzde darboğaz "nasıl yapılacağı" değil, "neyin yapılmaya değer olduğu." Yanlış bir problemi kusursuzca kodlayanlar, doğru problemi yarım yamalak çözenlerin tozunu yutacak.
Peki neyin yapılmaya değer olduğunu nasıl bulacağız? Andrew Ng'nin bunun için "Acımasız 3 Adımlı Filtresi" var:
• 1. Filtre: Gerçekten kimin umurunda? Sadece size "havalı" gelen projelere aşık olmayın. İnsanların para ödeyeceği veya her gün kullanacağı gerçek bir dert çözüyor musunuz?
• 2. Filtre: Yapay zeka buna tek atabilir mi? Sıradan bir chat botuna yazılacak tek bir komutla (prompt) çözülebilen bir işe vakit kaybetmeyin. Asıl değer; yapay zeka ile sizin sektörel bilginizin ve özel verilerinizin kesiştiği yerdedir.
• 3. Filtre: 7 günde yayına alabilir misin? (En önemlisi) Altı ay gizlice "mükemmel" ürünü geliştirmeye çalışanlar her zaman kaybeder. Geleceğin kazananları; utanç verici, çirkin ama "çalışan" bir versiyonu hızla piyasaya sürüp eleştirilerle büyüyenlerdir.
Mükemmeliyetçiliği unutun. Şu anki oyunun kazananları en temiz kodu yazanlar değil; doğru problemi bulup, rakipleri daha düşünme aşamasındayken o "çirkin" ilk versiyonu çoktan piyasaya sürenlerdir.
Stanford University just released free online courses.
No payment Required.
Here are best courses you don't want to miss in 2025:
Caution! this post is about why LatticA is fast, and it does contain a bunch of Fully homomorphic encryption, FHE / lattice-crypto stuffs
Hi! We’re finally able to share one of our core research results.
If you’ve seen our Gitbook, one of the mysterious keywords there was “Primitive Gate”.
Paper is now on ePrint: https://t.co/sY44AoasGD
[For the record, we even pre-committed to the name in the docs: SHA256("Primitive Gate") = f321ce2f5032c6d408f553606755b51378366c99adfa37337c95c1a330577139, see: https://t.co/g0ykztlGeW]
Gate FHE doesn’t do fast SIMD like other schemes.
Instead, it shines in low latency for single operations + small evaluation keys (public-key-like).
Let’s call this style latency-first FHE.
In the early days you could only homomorphically evaluate gates (AND/OR/XOR).
Building integer arithmetic by stacking tons of gates was… painfully inefficient.
To fix that, the community moved toward programmable bootstrapping (PBS) and LUT-based approaches:
You “program” a small lookup table (LUT) and evaluate it homomorphically.
Very much like compiling logic with LUTs on an FPGA.
People tried to increase LUT input bits / output bits to make it more powerful.
But as LUTs got more powerful, we started to lose the “latency-first” advantage.
Evaluation keys exploded in size, to the point where some schemes no longer fit comfortably in a web browser.
(Example: big-key FHE stacks end up needing server-side or heavy environments instead of “runs anywhere” crypto.)
We took a step back and asked:
“Is maximizing LUT power really the right direction for latency-first FHE?
Even if LUTs stay small, is there another axis we can push?”
This led us to define a function class called the
blind rotation function family (BRFF) and explore that space instead.
The “oh wow” moment:
Latency-first FHE should be generalized not by LUTs, but by BRFF.
You don’t have to keep making LUTs bigger – you can widen the function class that BRFF can handle.
We call the resulting function family Primitive Gate.
Very informally, Primitive Gate includes:
The usual gate ops from latency-first FHE:
AND, OR, XOR
Mixed gates like:
AND-XOR, OR-XOR
XOR6: a 6-input XOR
(the “6” is generalizable; FHE16 currently uses up to 6 inputs)
MAJ3(x, y, z) = (x AND y) OR (x AND z) OR (y AND z)
– the 3-input majority function
EQ3(x, y, z) = 1 if (x == y == z), else 0
The key punchline:
All of these run in essentially the same latency as a normal gate,
and we don’t blow up key sizes like in PBS-heavy designs.
No “one op is much slower”, no monstrous evaluation keys.
Also important:
This work does not assume a new cryptographic hardness assumption.
it’s a new fact, so you can treat it as “safe to use” even though the paper is on the archive right now.
So what does this mean for LatticA and FHE16?
FHE16 was already fast.
By exploiting the Primitive Gate capability, LatticA can push further:
Faster than state-of-the-art FHE in our target setting
Smaller key sizes at the same time
That’s the core story behind why LatticA can be both fast and browser-friendly.
Next steps / roadmap
A) We’re not done yet
There are still several research results / papers in the pipeline.
We’ve already left cryptographic “commitments” (hashes) to them in the Gitbook and are excited to reveal them one by one.
B) Most FHE research pours effort into hardware acceleration:
GPU, FPGA, ASIC…
But many blockchain folks we spoke to don’t just want “some vendor’s FHE in their data center”.
They want:
“FHE that runs in my browser, on my phone.”
We think that direction is very cool.
So before we rush to build accelerators, our next concrete goal is:
Put FHE16 in the web browser,
so that users can directly compute on ciphertexts in the front end.
Stay tuned :)
@Isley1249 , @thegimsin , @Scarrots93 , @DJShin73
![LatticAwaLLLnut's tweet photo. Caution! this post is about why LatticA is fast, and it does contain a bunch of Fully homomorphic encryption, FHE / lattice-crypto stuffs
Hi! We’re finally able to share one of our core research results.
If you’ve seen our Gitbook, one of the mysterious keywords there was “Primitive Gate”.
Paper is now on ePrint: https://t.co/sY44AoasGD
[For the record, we even pre-committed to the name in the docs: SHA256("Primitive Gate") = f321ce2f5032c6d408f553606755b51378366c99adfa37337c95c1a330577139, see: https://t.co/g0ykztlGeW]
Gate FHE doesn’t do fast SIMD like other schemes.
Instead, it shines in low latency for single operations + small evaluation keys (public-key-like).
Let’s call this style latency-first FHE.
In the early days you could only homomorphically evaluate gates (AND/OR/XOR).
Building integer arithmetic by stacking tons of gates was… painfully inefficient.
To fix that, the community moved toward programmable bootstrapping (PBS) and LUT-based approaches:
You “program” a small lookup table (LUT) and evaluate it homomorphically.
Very much like compiling logic with LUTs on an FPGA.
People tried to increase LUT input bits / output bits to make it more powerful.
But as LUTs got more powerful, we started to lose the “latency-first” advantage.
Evaluation keys exploded in size, to the point where some schemes no longer fit comfortably in a web browser.
(Example: big-key FHE stacks end up needing server-side or heavy environments instead of “runs anywhere” crypto.)
We took a step back and asked:
“Is maximizing LUT power really the right direction for latency-first FHE?
Even if LUTs stay small, is there another axis we can push?”
This led us to define a function class called the
blind rotation function family (BRFF) and explore that space instead.
The “oh wow” moment:
Latency-first FHE should be generalized not by LUTs, but by BRFF.
You don’t have to keep making LUTs bigger – you can widen the function class that BRFF can handle.
We call the resulting function family Primitive Gate.
Very informally, Primitive Gate includes:
The usual gate ops from latency-first FHE:
AND, OR, XOR
Mixed gates like:
AND-XOR, OR-XOR
XOR6: a 6-input XOR
(the “6” is generalizable; FHE16 currently uses up to 6 inputs)
MAJ3(x, y, z) = (x AND y) OR (x AND z) OR (y AND z)
– the 3-input majority function
EQ3(x, y, z) = 1 if (x == y == z), else 0
The key punchline:
All of these run in essentially the same latency as a normal gate,
and we don’t blow up key sizes like in PBS-heavy designs.
No “one op is much slower”, no monstrous evaluation keys.
Also important:
This work does not assume a new cryptographic hardness assumption.
it’s a new fact, so you can treat it as “safe to use” even though the paper is on the archive right now.
So what does this mean for LatticA and FHE16?
FHE16 was already fast.
By exploiting the Primitive Gate capability, LatticA can push further:
Faster than state-of-the-art FHE in our target setting
Smaller key sizes at the same time
That’s the core story behind why LatticA can be both fast and browser-friendly.
Next steps / roadmap
A) We’re not done yet
There are still several research results / papers in the pipeline.
We’ve already left cryptographic “commitments” (hashes) to them in the Gitbook and are excited to reveal them one by one.
B) Most FHE research pours effort into hardware acceleration:
GPU, FPGA, ASIC…
But many blockchain folks we spoke to don’t just want “some vendor’s FHE in their data center”.
They want:
“FHE that runs in my browser, on my phone.”
We think that direction is very cool.
So before we rush to build accelerators, our next concrete goal is:
Put FHE16 in the web browser,
so that users can directly compute on ciphertexts in the front end.
Stay tuned :)
@Isley1249 , @thegimsin , @Scarrots93 , @DJShin73](https://pbs.twimg.com/media/G66KZpqbcAAk9ic.png)
Meet the growing privacy & confidentiality ecosystem on Solana 👇
This is an explanation of why waLLLnut’s FHE16 is so important and practical compared to existing FHE schemes.
Caution! this post is about why LatticA is fast, and it does contain a bunch of Fully homomorphic encryption, FHE / lattice-crypto stuffs
Hi! We’re finally able to share one of our core research results.
If you’ve seen our Gitbook, one of the mysterious keywords there was “Primitive Gate”.
Paper is now on ePrint: https://t.co/sY44AoasGD
[For the record, we even pre-committed to the name in the docs: SHA256("Primitive Gate") = f321ce2f5032c6d408f553606755b51378366c99adfa37337c95c1a330577139, see: https://t.co/g0ykztlGeW]
Gate FHE doesn’t do fast SIMD like other schemes.
Instead, it shines in low latency for single operations + small evaluation keys (public-key-like).
Let’s call this style latency-first FHE.
In the early days you could only homomorphically evaluate gates (AND/OR/XOR).
Building integer arithmetic by stacking tons of gates was… painfully inefficient.
To fix that, the community moved toward programmable bootstrapping (PBS) and LUT-based approaches:
You “program” a small lookup table (LUT) and evaluate it homomorphically.
Very much like compiling logic with LUTs on an FPGA.
People tried to increase LUT input bits / output bits to make it more powerful.
But as LUTs got more powerful, we started to lose the “latency-first” advantage.
Evaluation keys exploded in size, to the point where some schemes no longer fit comfortably in a web browser.
(Example: big-key FHE stacks end up needing server-side or heavy environments instead of “runs anywhere” crypto.)
We took a step back and asked:
“Is maximizing LUT power really the right direction for latency-first FHE?
Even if LUTs stay small, is there another axis we can push?”
This led us to define a function class called the
blind rotation function family (BRFF) and explore that space instead.
The “oh wow” moment:
Latency-first FHE should be generalized not by LUTs, but by BRFF.
You don’t have to keep making LUTs bigger – you can widen the function class that BRFF can handle.
We call the resulting function family Primitive Gate.
Very informally, Primitive Gate includes:
The usual gate ops from latency-first FHE:
AND, OR, XOR
Mixed gates like:
AND-XOR, OR-XOR
XOR6: a 6-input XOR
(the “6” is generalizable; FHE16 currently uses up to 6 inputs)
MAJ3(x, y, z) = (x AND y) OR (x AND z) OR (y AND z)
– the 3-input majority function
EQ3(x, y, z) = 1 if (x == y == z), else 0
The key punchline:
All of these run in essentially the same latency as a normal gate,
and we don’t blow up key sizes like in PBS-heavy designs.
No “one op is much slower”, no monstrous evaluation keys.
Also important:
This work does not assume a new cryptographic hardness assumption.
it’s a new fact, so you can treat it as “safe to use” even though the paper is on the archive right now.
So what does this mean for LatticA and FHE16?
FHE16 was already fast.
By exploiting the Primitive Gate capability, LatticA can push further:
Faster than state-of-the-art FHE in our target setting
Smaller key sizes at the same time
That’s the core story behind why LatticA can be both fast and browser-friendly.
Next steps / roadmap
A) We’re not done yet
There are still several research results / papers in the pipeline.
We’ve already left cryptographic “commitments” (hashes) to them in the Gitbook and are excited to reveal them one by one.
B) Most FHE research pours effort into hardware acceleration:
GPU, FPGA, ASIC…
But many blockchain folks we spoke to don’t just want “some vendor’s FHE in their data center”.
They want:
“FHE that runs in my browser, on my phone.”
We think that direction is very cool.
So before we rush to build accelerators, our next concrete goal is:
Put FHE16 in the web browser,
so that users can directly compute on ciphertexts in the front end.
Stay tuned :)
@Isley1249 , @thegimsin , @Scarrots93 , @DJShin73
Not a bad start!
https://t.co/w2DvZyeCBC
Thank @tom_piskule for selecting LatticA as one of the most interesting projects in the infrastructure category
Moving on to the backbone of the ecosystem: the Infrastructure track from the @colosseum Cypherpunk Hackathon. 🏗️ Here is my selection of the most interesting projects from this category: 👇
Overdrive by @predictionindex - real-time dashboard and intelligence network for prediction markets where encrypted, incentive-based signals bring insiders and traders together to move as one, with instant cross-chain execution
@hyperonsol - data infrastructure as code
@unruggable_io - hardware wallet and companion app
@anon0mesh - privacy oriented messaging and private transactions app using Bluetooth
@PineAnalytics - blockchain analytics platform that captures, aggregates, and interprets on-chain data in real time
@LatticAwaLLLnut - deterministic confidential computing
SYLO by @botanika_sol - sovereign cloud dApp for Solana Mobile
@mynoraai - AI coding agent for Web3
@AiMoNetwork - permissionless API, pay-per-inference via x402, and agent-native interface
@CatScope_io - MEV marketplace bridging traders & validators
@EremosCore - framework for deploying autonomous swarm agents that detect early on-chain activity
@GavernApp - comprehensive governance infrastructure providing DAOs with structured role management, treasury tracking, and actionable insights
@radrdotfun - powering ZK payments, identity, and communication
Honourable mention:
@IQLabsOfficial
SolSab Fuzzer by @Sablier
@surgeswapxyz
Velane by @shardvellcom
@fystack
@mcpaytech
@TRUSTBYTES_X
https://t.co/feRFrVd8pm (FHE16 paper)
Warning: this thread goes pretty deep into cryptography.
Today we want to talk about FHE16, the fully homomorphic encryption (FHE) scheme we’ve been pushing.
FHE16 is fast for essentially the same reason we could run DeepSeek on low-spec hardware: heavy use of low-precision computation.
More precisely, FHE16 uses integer arithmetic, so the usual notion of “precision” doesn’t really apply. (Also, since we use the Number Theoretic Transform instead of the Fast Fourier Transform, it’s always correct.)
Instead, we design the modulus Q of the ring used during bootstrapping (homomorphic evaluation) as a product of two primes p1 and p2, each smaller than 16 bits.
(Currently, the security of homomorphic encryption is typically proven under two main assumptions: the Learning With Errors (LWE) assumption and the key-dependent message assumption. In earlier LWE work, proofs often assumed Q was prime, but later research has shown that the exact form of Q doesn’t matter much—as long as its size is appropriate.)
This means we can use the Chinese Remainder Theorem to compute over two systems, Z_p1 and Z_p2. Historically, this technique was mostly used in throughput-first FHE schemes like CKKS and BGV/BFV, which speed things up by packing data.
By leveraging this technique and designing the ciphertext computation system so that everything stays within a ≤16-bit modulus, we were able to significantly improve overall performance.
(It’s not that things “magically” get faster; this design unlocks a lot of implementation-level advantages—but there are too many to list here one by one.)
Remark. The FHE16 performance you see in LatticA is actually not just the result of the paper above. Another paper explaining how we managed to make it this fast is scheduled to be released later this month, so please stay tuned.
@Scarrots93 , @Isley1249, @DJShin73
At Walllnut, our project LatticA is also advancing the frontier of private transactions for onchain capital markets, powered by Fully Homomorphic Encryption (FHE).
We’re building the foundation for a world where privacy and composability can truly coexist — and we’re proud to be contributing to this future.
#Walllnut #LatticA
Someone’s making a “LatticA walllnut coin” after just one month — not us, btw! 🚫
So this is how waLLLnut’s value finally gets recognized — quite an episode! Just don’t let anyone take a hit 😆
wtf are you guys doing.
That https://t.co/pnUSDxG0YK coin is NOT us. We have NO token, do not buy. The Solana Colosseum lending app was just a demo, not a launch, and even not our final mission. Our ultimate mission is an optimistic, time-controlled ‘open’ primitive on-chain. No token for at least 1–2 years.
https://t.co/RwKLV5ds1g
@LatticAwaLLLnut So this is how waLLLnut’s value finally gets recognized — quite an episode! Just don’t let anyone take a hit 😆
@LatticAwaLLLnut The idea of performing computations on encrypted data—data that is meant to be hidden—is inherently ironic.
Yet, if implemented properly, it enables a new class of services. It’s clear that waLLLnut’s FHE16 is the most suitable homomorphic encryption system to achieve this.
@ham379888 핵심 모듈 개발과 이들을 시스템에 integration하는 것은 다른 이야기지요. 후자는 전체 시스템에 대한 이해와 경험이 있어야 하므로 상대적으로 이를 제대로 하는 개발자는 드뭅니다. 수고 많으셨네요.
@LatticAwaLLLnut @jacobvcreech @colosseum FHE16 — faster, smaller, and fully deterministic homomorphic encryption engine!
https://t.co/sPmFCov7Re
“With cryptography there’s an opportunity to build a single financial rail for the entire world
Solana has the throughput and latency to cover basically every market in the world at the same time”
@LatticAwaLLLnut We hope this will be a great opportunity to show how waLLLnut’s confidential coprocessor can make the RWA market safer and fairer.
Last Seen Users on Sotwe
Trends for you
Most Popular Users
Elon Musk 
@elonmusk
241.7M followers
Barack Obama
@barackobama
119M followers
Cristiano Ronaldo
@cristiano
114.4M followers
Donald J. Trump
@realdonaldtrump
111.9M followers
Narendra Modi
@narendramodi
107.2M followers
Rihanna
@rihanna
98.7M followers
NASA
@nasa
92.4M followers
Justin Bieber
@justinbieber
91.8M followers
KATY PERRY
@katyperry
90M followers
Taylor Swift
@taylorswift13
83.9M followers
Lady Gaga
@ladygaga
75.4M followers
Virat Kohli
@imvkohli
73.3M followers
Kim Kardashian
@kimkardashian
70.9M followers
YouTube
@youtube
68.8M followers
Neymar Jr
@neymarjr
66.3M followers
Bill Gates
@billgates
65.1M followers
Selena Gomez
@selenagomez
63M followers
The Ellen Show
@theellenshow
62.3M followers
CNN
@cnn
61.8M followers
X
@x
60.7M followers