Stackr Labs’ mission is ambitious yet simple: Empower every developer to build scalable web3 apps.
Today, decentralized app development is constrained to a niche subset of crypto-natives. Our goal is to make it accessible for all - to break down the barriers between web2 and web3 by making it easy to build and operate rollups.
As our first step towards this goal, we are introducing the Stackr SDK - a framework to build app-specific micro-rollups in web2 programming languages. In the rest of this post, we’ll walk through these concepts and our thinking behind the SDK, our long-term vision and near-term focus.
Appchains, meet rollups
Ethereum and Cosmos visions are colliding.
The Ethereum ecosystem has recognized the value of app-specific blockspace for customizability, performance and value capture. Meanwhile, the Cosmos ecosystem has recognized the value of shared security for trust-minimization and easier chain operations. App-specific rollups realize the best of both worlds and are quickly gaining mindshare.
However, it’s still very hard to build rollups, let alone app-specific rollups. Most existing rollups are general purpose, take a long time to build, require deep crypto expertise and use custom software.
Stackr solves this problem with an SDK for building app-specific rollups. We let developers easily customize execution environments to fit their use cases.
How we think about rollups
Before further illustrating our approach, let’s take a step back. The rollup design space is large, complex and dynamic, so it’s important that we first establish a fundamental understanding of the technology.
Rollups are often misunderstood - they simply compute over transactions off-chain and store the results and input data on-chain. Kelvin from Optimism recently offered a great mental model in his ETHGlobal presentation. A rollup is “a function over an input array”. We agree, and through this lens, any finite state machine that computes over an on-chain input array can be considered a rollup. Rollups are not limited to the EVM, SVM, Move VM, or any crypto-native VMs!
Break up the monoliths
One thing web2 got very right was the micro-services architecture. The design philosophy involves breaking down a larger system or application into smaller components, each responsible for specific functions. For example, a given application might have authentication, data storage, and messaging functions built as separate micro-services. This approach brings many benefits to developers - agility, flexibility, upgradability, efficiency, reusability, etc.
For similar reasons, web3 is also adopting this design philosophy. It underlies the shift towards modular blockchains and app-specificity.
Here come the micro-rollups
Stackr is going a step further - from app-specificity to logic-specificity. We are introducing the concept of micro-rollups, where individual functions within a decentralized app are developed, optimized and maintained as independent state machines. Referencing the micro-services analog, you can think about regular rollups —> micro-rollups similar to monoliths —> micro-services or VMs —> containers.
Here are two ways to visualize the differences:
Developers can use the Stackr SDK to define data structures for their application’s state and state transition function. Under the hood Stackr will do the heavy lifting, providing an API to interact with the app, connect it to the aggregator network (more on this later) and finalize on L1.
As an example application, let’s say you write a merkle tree with leaves that hold account addresses and token balances. You have just built yourself an account-book rollup. Now replace ECDSA with BLS and you have a working version of Hubble, the most efficient ERC-20 transfer rollup as well as (fun fact!) the first ever app-specific rollup!
Program in languages you already love
The Stackr SDK is very flexible and allows developers to use programming languages of their choice. We believe that to truly make web3 app development widely accessible, we must meet developers where they are. Python, JavaScript, Go, C, etc. - these are the languages that millions of developers worldwide already know and love.
Stackr Labs is also developing pre-built state machine and bridging modules that make it easy for micro-rollups of different languages to interact. Imagine an app that uses one Python-based micro-rollup and another JavaScript-based micro-rollup, both optimized for the task at hand.
Here’s a way to visualize composable micro-rollups leveraging different languages and an aggregator network:
Sufficiently decentralized apps
There are many exciting apps in the space, but one we find worth highlighting is Farcaster, a “sufficiently decentralized social network”. The Farcaster team detailed their thinking behind “sufficient decentralization” in this post, but the core idea is that sometimes putting entire apps on-chain is “unnecessary and undesirable”.
Their POV is that “a social network achieves sufficient decentralization if two users can find each other and communicate, even if the rest of the network wants to prevent it” and that “achieving this only requires three decentralized features: the ability to claim a unique username, post messages under that name, and read messages from any valid name.”
To be very clear - we at Stackr Labs believe in open and permissionless innovation. Build anything you want and put any of it on-chain. However, we do find the Farcaster design approach (and social network use case) interesting and a fantastic match for micro-rollups and the Stackr SDK. We aim to make it easy for developers to decentralize the bits that matter.
Example use cases and applications
The capacity of rollups to validate any off-chain computation represents a remarkable superpower that can be harnessed to create highly efficient use cases for distributed computing. Here are some examples to get the juices flowing:
-
Games. Build immersive, interactive games in JS or Unity by converting each user action into an L2 transaction. Rollups provide exciting new opportunities for the development of sophisticated gaming applications with unprecedented levels of interactivity.
-
Databases and cloud services. Build a full-fledged database system and index structured and unstructured data within L2 nodes or build entire cloud service stacks like Lambda or identity management tools.
-
Oracles and real world data. Have seamless integration of off-chain data sources such as social graphs, user credit scores, KYC and identity systems. Build attestation applications or run an entire DAO as a rollup with advanced access control and grants processes.
-
Off-chain multi-nodal networks. Develop comprehensive distributed applications. Provide novel on-chain services to users by enabling nodes to interact with each other through a rollup network.
-
Social algorithms. Build a trending algorithm micro-rollup to power the news feed of your Farcaster client.
-
Machine learning. Deploy models for inference as Python micro-rollups. Let users verify it’s truly GPT-2 and not GPT or some other flavor.
-
DeFi and NFTs. Build an AMM DEX in Python or C++ using composable micro-rollups for token transfer + token pool + oracle + AMM logic.
-
Enterprise applications. Build private and semi-private applications with robust data access controls. For example, an end-to-end supply chain management system with view permissions for the public but write permissions reserved for authorized parties.
-
No limits! We are only starting to unlock the full potential of rollups for distributed computing. Build secure and reliable communication infrastructure, multi-party compute systems like folding@home, distributed video transcoding systems like Livepeer, privacy-focused transaction ledgers like Aztec or a massive open world game like Minecraft. Build anything from middleware for wallets to entire cloud services like AWS - there’s a huge design space for verifiable compute.
Product vision
Now let’s talk about our vision for Stackr Labs and the technologies we are building.
Modular and agnostic SDK
The Stackr SDK will support many web2 programming languages such as Python, JavaScript, Go, C, Rust and more - our goal is to be language agnostic. The SDK will also be as flexible as possible regarding proofs (fraud and validity), rollup types (classic and sovereign), ordering (centralized and decentralized) and base layers.
Decentralized aggregator network
Stackr Labs is also building an aggregator network that receives interaction data from applications (along with new states and metadata), bundles the data and submits it on-chain. You can think of the aggregator network like bundlers in EIP-4337, except with rollup data.
We will be sharing much more information about this layer over the coming months!
Near-term focus
To start, the Stackr SDK will focus on Python and JavaScript programming languages. It will support sovereign rollup mode and ordering will be done by the applications. The initial version will be released without proofs enabled, while we build out the aggregator network, and focus on Ethereum as a base layer.
Where to find us
The Stackr Labs mission is to empower every developer to build scalable web3 apps. It’s an ambitious goal and there’s plenty of work ahead. If the mission resonates with you as a builder or potential team member, please reach out!
-
We’re hiring! Join our team
-
Eager to build with us? Join the waitlist
Whether you’re looking to deploy an existing project as a rollup, starting a new project or still in the idea maze, we’d love to collaborate with you.
We plan to build in public and will be releasing much more information over the coming months. Excited to have you on this journey with us - let’s “roll” homies 🚀
Special thanks
Shoutout to our advisors, investors and everyone helping out along the way: @litocoen @RHLSTHRM @anuragarjun @arjunbhuptani @norswap @NoahCitron @musalbas @DannySursock @AshAEgan @stonecoldpat0 @sunnydece @VirtualElena @guywuolletjr @ljxie @sanjaypshah @nuss_eli @jacobkxyz @jadbc0x @sjors_lemniscap @jessziyuezhang @devfolio and many others