It was an intimate and intentionally curated 30–40 person gathering during DevConnect. Organized by WakeUp Labs with support from the Arbitrum DAO, the event took place at Tomate and brought together key teams, managers, and project leads contributing to Stylus who were in Argentina for the conference. Among the guests were several notable companies: VeloraDAO, Arbitrum Foundation, Overboost, OSO (Open Source Observer), Hack VC, Arbitrum DAO, Off Chain Labs, Rather Labs, Co-Builders, Sherlock, Uphold, 9Lives, Fuul, DZap, EmberAi, Usher, POAP, Quantum3Labs, Messari, Oak Security, Red Stone, Entropy Advisors, Walnut, and many more who were invited as speakers, making it a fantastic opportunity to connect.

Keeping it small was intentional.. A tightly connected Arbitrum ecosystem, where teams work closely together, helps strengthen relationships, improve code quality, share insights more openly, and ultimately build stronger connections across the community.

Agenda and Speakers

• Offchain Labs — Srinjoy Chakraborty

• ​Superposition — Alex Baigent (Joined the event but couldn’t deliver his talk for health-related reasons)

• WakeUp Labs — Milton Berman

• ​Fairblock — Peyman Momeni

• ​Fairgate

Srinjoy from Offchain labs opened the session by discussing the current state of Stylus and what’s ahead.. One of the most interesting insights he shared was how the adoption strategy has evolved: initially, the approach was a bottom-up, expecting more and more developers to learn Stylus over time, and eventually bring it into larger protocols. But this year, the focus is shifting toward having established protocols implement Stylus first. By showcasing big success stories, where those protocols save gas and perform much better than others, we can draw the attention of larger protocols and give them clear incentives to implement Stylus.

He also highlighted an interesting detail: at least 50% of the teams mentioned throughout his presentation, those actively contributing to Stylus, were actually present at the event. It shows that even though the ecosystem is still small, it’s forming a real nucleus where contributors can connect, support each other, and implement improvements together.

Another thing he mentioned was that even though the number of contributors hasn’t been very high, around 50 teams working in the Arbitrum Stylus world, their impact has been substantial. There are already more than 17,000 contracts deployed on testnet, and many of them will likely move to mainnet soon. This means the technology is starting to prove itself, and we’re reaching a point where it can be adopted on mainnet without any issues.

The Offchain Labs speaker also spoke about challenges that teams and builders faced this year, such as strict contract size limits, limited early tooling, and the difficulty of managing multi-contract workflows, and how many of these pain points are now being addressed with upcoming releases, including an increase in the contract size limit, and better debugging, testing, and deployment flows. Finally, he suggested a shift in how Stylus adoption should be measured: rather than focusing only on the number of developers or deployed apps, the goal is to make Stylus modular, so that existing Solidity protocols can plug in Stylus-powered components without having to write Rust or AssemblyScript themselves.

The second talk was delivered by Sergio Lerner from Fairgate, who shared how their work on “disputable computation” for Bitcoin connects directly with what Stylus makes possible on Arbitrum. He started by framing the core problem: building truly decentralized bridges requires heavy computation, because you need to verify another chain’s consensus or, in an optimistic model, be able to dispute and prove a single faulty step in a long computation.

From there, he connected the dots with Stylus and Arbitrum.

In order to make these Bitcoin–L2 bridges practical, the non-Bitcoin side needs to implement a fairly complex set of components: bridge contracts, dispute logic, and especially a Bitcoin SPV oracle that performs intensive hashing and cryptographic checks. On Ethereum, similar oracles were prohibitively expensive to keep updated, which limited their real-world use. With Stylus, those same cryptographic workloads can be implemented in Rust and run far more efficiently on Arbitrum, making it feasible to maintain rich, on-chain views of Bitcoin and to manage incentives and payouts directly in smart contracts. In Sergio’s view, this creates a very natural match between BitVMX and Stylus, it brings scalable, optimistic verification to Bitcoin, while Stylus provides the execution environment where those bridges and oracles can actually live and scale, opening a path for deeply decentralized, economically viable bridges between Bitcoin and the Arbitrum ecosystem.

Next up, Milton Berman from WakeUp Labs, walked through how his team is using Stylus to lower the barrier for developers who want to build on Arbitrum. WakeUp Labs has been working closely with the ecosystem over the past years on tools like Arbitrum Connect and ZK verifiers, and Milton used that context to introduce their latest effort: an AssemblyScript SDK for Stylus.

The core idea is straightforward: Stylus lets you write smart contracts in languages that compile to WASM, and AssemblyScript is essentially a subset of TypeScript. That means millions of TypeScript developers can get into onchain development without having to fully switch mental models or learn Solidity from scratch. Milton showed recent GitHub data where TypeScript has surpassed Python in yearly contributor growth, and framed the SDK as a way to tap into that existing talent pool for Arbitrum.

From a developer point of view, the workflow looks familiar: use a simple CLI to generate a project, write contracts in TypeScript-like syntax with decorators, run tests, and compile to WASM for Stylus. Under the hood, the SDK takes care of the hard parts, adapting TypeScript to AssemblyScript, handling storage patterns, and producing the bytecode and ABIs needed to deploy on Arbitrum. Milton also shared early metrics from an ERC-20 implementation: smaller contract size, cheaper deployment, and faster execution in some operations, with plenty of room left for optimization as the SDK matures.

For the ecosystem, his message was clear: Stylus isn’t just about performance; it’s about widening who can build on Arbitrum, turning front-end and TypeScript developers into onchain builders with a much smoother learning curve.

After Milton’s talk, the focus shifted from developer experience and language accessibility on Stylus to a different, but equally critical, dimension: privacy.

Peyman Momeni from Fairblock closed the day by showing how Stylus can power confidential stablecoins and sealed-bid auctions that preserve users’ strategies without relying on opaque offchain coprocessors.

Peyman began by explaining how Fairblock’s journey evolved from building pure cryptography primitives for other teams to creating fully integrated applications themselves, mainly because convincing protocols to adopt deep cryptographic tooling proved to be an extremely difficult challenge. By building complete, vertical applications, their hope is that Stylus developers can simply fork, adapt, and build on top of their work.

Fairblock works on confidentiality, where addresses remain visible, but amounts and contract interactions are encrypted. This model mirrors how banks operate: your identity is known, but your account details and transaction amounts are not public.

From there, Peyman showed why confidentiality is not ideological, it’s economic. He cited real-world examples: dark pools in traditional finance, iceberg orders, and confidential trading workflows where traders hide amounts to avoid being front-run. Onchain, the same applies to salary payments, market-making flows, and lending auctions.

He introduced Fairblock’s two main applications running on Arbitrum with Stylus: confidential stablecoins, where balances and transfer amounts are encrypted but traceability is preserved; and Fair Rates, a system for fixed-rate lending built on encrypted sealed-bid auctions. Stylus plays a crucial role here: cryptographic operations that would be impractically expensive or too slow in Solidity can be efficiently implemented in Rust through Stylus, enabling onchain decryption, encrypted bidding, and complex auction settlement logic at practical cost.

Peyman closed by emphasizing why Stylus matters so much for privacy research: cryptographers write real cryptography in Rust and C, not Solidity. Stylus lets those tools run efficiently within the EVM environment, bridging the gap between high-performance cryptography and composable DeFi. In his view, Stylus opens a path where privacy-preserving applications can finally be built natively on Arbitrum, without off-chain coprocessors, without trust assumptions, and without waiting years for new precompiles on L1.

As the event wrapped up, one thing was clear: Stylus is no longer an experiment. It is becoming a shared layer where different teams, from cryptographers to infrastructure builders to application developers, can meaningfully collaborate. Seeing so many contributors in the same room, exchanging ideas and aligning on what comes next, made this gathering much more than a side event. It felt like the early formation of a technical community around Stylus, one that is ready to build the next wave of applications on Arbitrum.