Lurk Lab

Building high-performance privacy @proofbase_xyz, powered by Lurk

[Lurk Lab @LurkLab]

👀

[Nicolas Ramsrud @NicolasRamsrud]

boy are we cooking. its only the 11th and we have almost surpassed all of august

[Nicolas Ramsrud @NicolasRamsrud]

great article on optimization in zk

re: optimizing zkvms with a custom instruction set

we showed with our Lurk 0.5 release that a purpose built language and minimal machine yields a far more efficient prover, upwards of 10x faster in some tests, while also simplifying the pipeline.

this is without compilation, purely interpreted Lurk code, and a zkvm that had not yet had any optimization work done.

more here: https://t.co/OhbDD26Eol

we are working on the next iteration of this work, Lurk 2.0, that includes memoization and a compilation pass that optimizes the DAG of reduction into an optimal series of lookups prior to proof generation. This gets us closer to achieving optimal performance and separates the semantic specification of what computation ought to happen from the operational details of how it is proven. This work was recently submitted to the Journal of Functional Programming and will be available soon.

its not clear yet what this will provide in performance, but it could be an order of mag or more. (and thats on Plonky3/SP1)

So yes, custom language, compiler and machine can most definitely yield 100x+ improvement in performance.

[Porçu Quine @porcuquine2]

Here's a snapshot of what we're working on at @LurkLab. This also serves as a snapshot of the kind things coding agents can plausibly accomplish these days.

[Nicolas Ramsrud @NicolasRamsrud]

-----------------------
NEW BLOG POST
LurkScript, Concurrent Lurk and LurkOS
-----------------------

I have gotten a lot of questions about the application model and execution environment we are developing for @Proofbase_xyz

It is unlike anything else out there and has many reasons behind each design decision

- JavaScript surface syntax
- natively asynchronous language and application model
- capability-scoped kernel
- content-addressed, queryable resources
- functional handlers
- domain-specific routing of messages
- for isolated private state with permissionless composability

LurkOS defines how applications structure state, communicate, and compose safely.

blog link below⬇️

[Lurk Lab @LurkLab]

Lurk is how legacy systems will be brought onchain

[Nicolas Ramsrud @NicolasRamsrud]

I have been saying a long time that a massive unlock with Lurk is the ability to connect legacy systems to blockchain.

Proofpay is our first product that does just that.

Extend existing ERP workflows to automate private stablecoin settlement through approvals, payments and reconciliations. No blockchain UX in sight.

All possible with LurkOS, powered by @SuccinctLabs SP1, on @Proofbase_xyz

[Nicolas Ramsrud @NicolasRamsrud]

LurkOS: the provable operating system

We have been heads-down over the past couple of months, building the future of private, composable, async applications.

The result? LurkOS.

Not just a zkVM, but a fully programmable execution environment that allows you to spawn independent LurkOS instances as actors, run processes and applications with defined interfaces, message between them and inter-agent, all provably and privately.

and the performance isn't too bad either (20k+TPS shown in demo).

LurkOS is the execution environment that will run on top of @Proofbase_xyz which provides the trustless message passing layer for trust-gapped LurkOS instances.

Soon this will be powered by @SuccinctLabs SP1 for real-time privacy.

[Nicolas Ramsrud @NicolasRamsrud]

we are quietly shipping, anon

sneak peek at LurkOS, our provable operating system sending 100k transactions between actors

yes, this is all intra-actor and without proofs, but this is just the start.

[Lurk Lab @LurkLab]

👀

[Nicolas Ramsrud @NicolasRamsrud]

concurrent Lurk has been achieved internally

[Nicolas Ramsrud @NicolasRamsrud]

There is something fundamental in this that is not widely understood

building stateful proof-based applications over private data is fundamentally different

you cannot just wrap your program in zk

this requires language level support for operating over and manipulating private state

enabling these applications to permissionlessly interact (composability) with each other requires standardized interfaces and data language

you need a language build for privacy on a blockchain that is built for it

@NoirLang and @aztecnetwork is doing this

@0xPolygonMiden is doing this

@LurkLab and @Proofbase_xyz is doing this

few.

[Lurk Lab @LurkLab]

👀

[Nicolas Ramsrud @NicolasRamsrud]

is that JS fib running in LurkScript REPL?

Why yes it is.

[Lurk Lab @LurkLab]

LurkScript now works well enough to implement the Lurk standard library so far! Our modular design allows the lurk CLI REPL and prover to use the LurkScript CLI frontend to seamlessly add LurkScript support to Lurk.

https://t.co/HFw6ZYl3yX

[Proofbase @proofbase_xyz]

Mass adoption scale privacy will need real-time proving.

So we’re partnering with @succinctlabs to build toward that future on Proofbase!

[Proofbase @proofbase_xyz]

https://t.co/Bb7A0tUCDj

[Proofbase @proofbase_xyz]

The future demands privacy that can scale to billions.

Introducing Proofbase: the high-performance privacy layer for Ethereum.

https://t.co/B5YsSh2mii

[porter @portport255]

@NicolasRamsrud @0xLita Wow, I haven't kept up with Lurk. That's amazing. Okay @LurkLab is going on my study list 🤝

[Nicolas Ramsrud @NicolasRamsrud]

Lurk does something similar with similar results.

All data and code is commitment based, including proof I/O (which is then opened and committed to at each step of computation), so with content-addressed data storage you can generate proofs of computation over arbitrarily sized datasets stored in arbitrary locations. Even private data.

Although we use Poseidon to get const sized commitments, this makes me wonder if there is some PCS method to use as a commitment scheme for proofs over large datasets that would perform better than Poseidon.

[Nicolas Ramsrud @NicolasRamsrud]

A little view behind the curtain, anon.

You can now write provable JavaScript with Lurk.

This shows why Lurk is so powerful. It took just 5 weeks to make it possible to compile JS into a JS representation of Lurk that can either be interpreted in place as JS or passed through Lurk for proving.

Onwards to on-boarding millions of devs to ZK.

[Lurk Lab @LurkLab]

Provable JavaScript? Check.

Users can now write programs in JavaScript, compile to LurkScript, evaluate in place or pass through Lurk to generate a proof.

Getting ready for that Web2 scale ZK.

[Porçu Quine @porcuquine2]

My LurkScript implementation is now minimally feature-complete. This lets you author arbitrary Lurk programs in a (functional, immutable) subset of JavaScript. It's implemented in TypeScript, and will allow tight integration with the JS ecosystem, toolchain, and web application.