zk: The Most Beautiful Form of Privacy

In this article, I would like to discuss in more depth the topic of “zero-knowledge proofs”, an emerging technology still very much in prototyping stage, but becoming more and more accessible through projects and languages like Noir or Mina.

Note that I am still very new to zk, the following is just my initial insights after visiting a “protocol and infrastructure conference” titled Protocol Berg as well as a Web3 Privacy hackathon titled W3PN HACKS.

Why is this relevant?

At first, I didn’t understand the point of zk.

People explained it to me as “a way to prove that I have a certain piece of information without revealing it”.

But over a few days and seeing what people would build with it, I slowly started getting it. The thing is that we need to shift our model of computation drastically.

Traditional World

In the traditional world, we have a bunch of computers, but the data handled by that computer can generally be thought of as “being private to the process”. Of course not in all cases, but generally you assume a private memory space in RAM, where a process running in an operating system can only access its own memory, and (except for when granted special privileges by the user) cannot read the memory of other processes.

This is the foundation of how, for example, HTTPS works: The connection in the background uses public keys and private keys, and the browser must ensure that these private keys used during an individual HTTPS connection really stay private. Everything else would be a backdoor and/or a zero-day. So far, so good.

The Blockchain

Now comes the blockchain, and its primary goal is to establish a single point of truth for certain kinds of information without centralization. Whether that’s how many bitcoins you have or whether that’s an NFT you own or whatever, that doesn’t really matter. The one and only purpose and magic of the blockchain is: We can have a global network and because everyone agrees on the state of that network, we assume that this information is trustworthy.

It’s a social contract of saying “because I invest part of my electricity bill into this computer system, I assume that the information stored in this computer system is authoritative”.

But what if you want to keep certain economic information about yourself private?

Privacy is not Built-In

Let’s say you don’t want everyone to know how much money you have in your bank account. With many traditional cryptocurrencies like Bitcoin, Ethereum etc., you have permissionless, but replicated storage, where all nodes that are actually relevant to the network must store all transactions that ever happened in that chain.

Now we want to make some computations on that chain.

In ETH, that’s easy, just make a smart contract. But that’s still public. And that’s where zk comes in.

Why “proofs”?

In zk, we acknowledge that a blockchain system is, in some way, a mesh of computers, where all these computers are equal peers, who all execute identical logic. As smart contracts must handle data, consistency must be ensured not by just checking for two nodes A and B whether:

smart_contract_result_A(input) = smart_contract_result_B(input)

it now needs to effectively check:

decoded(smart_contract_result_A(encrypted(input))) = decoded(smart_contract_result_B(encrypted(input)))

And this is why it is so mathematical. In the end, we always need to show “0 = 0” (or “1 = 1” or whatever equivalent). When not using encryption, you just check whether the bits are identical. But when it comes to cryptography, it’s all mathematical and logic-based functions, XOR and stuff like that. And, in mathematics, the generalization of a basic comparison is a proof.

We need some way to “encrypt” the input in a certain way, and to “decode” the output later, so that any kind of validator can then determine whether to agree with another node or not.

In the context of zero-knowledge systems, the connection between encrypted inputs and verifiable outputs must happen via a proof.

The issue is not computing the result, but proving that a computation made on a different peer was done correctly.

Then there are the proof systems themselves, essentially the “engines” for these proofs. One example in the Aztec ecosystem is barretenberg, which uses zk-SNARK and plonk and all sorts of funny acronyms.

Innovation does still happen

At times, you can get a bit pessimistic in tech nowadays. Smartphones and microprocessors and even traditional blockchains are cool and all, but is that really it?

Tech nowadays is boring. Apple makes a wetter UI and sometimes a big crypto scam or Crowdstrike happens, and sometimes there’s the next cool web framework, but overall it’s all a bit… stale, I would say. Until I discovered zk.

It’ll definitely still need a few months or years to become fully production-ready. But when it will be, it can actually become pretty pleasant to use, focused on a value often violated in software design nowadays: privacy. And this is where it’s truly worth investing into good visual and user experience design, because I see zk as the next big step in large-scale infrastructural shift. There’s so much beyond it.

Make zk beautiful!

Outlook

As mentioned, I’m still very new to this. But from how I have understood it so far, zk can actually be pretty revolutionary.

Suddenly we get the option to have fully public infrastructure (i.e. all the nodes in a blockchain) and store fully encrypted data on it, but not in a way where either no one knows what my data is or everyone knows, but instead where I can selectively decide which data I want to share where, and that is decided using smart contracts.

One of the most popular projects in this space is Zcash (https://z.cash/), where I talked to an awesome community manager who explained to me that Zcash is far superior to Monero when it comes to privacy. And then I’ll be at ZK Hack next weekend too!

Thanks so much again to everyone else from the hackathon and feel free to check out the other submissions as well! See https://github.com/web3privacy/hackathon-2025-berlin-submissions