Lurk Lab

👀

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: blog.lurk-lab.com/posts/perf-202… 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.

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.

----------------------- 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 is how legacy systems will be brought onchain

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.

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.

👀

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.

👀

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. github.com/lurk-lab/lurk/…

Mass adoption scale privacy will need real-time proving. So we’re partnering with @succinctlabs to build toward that future on Proofbase!

The future demands privacy that can scale to billions. Introducing Proofbase: the high-performance privacy layer for Ethereum. proofbase.xyz

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

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.

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.

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.