TL;DR
This thread will keep you updated on our work integrating AssemblyScript (a TypeScript-like language) into the Arbitrum Stylus SDK.
Why does it matter? Because it lets developers write fast, efficient smart contracts using a language they already know.
Why AssemblyScript and the Stylus SDK?
The Stylus SDK already lets you build super fast smart contracts using Rust. But not every developer knows Rust. That’s where AssemblyScript comes in—it’s based on TypeScript, which many developers are already familiar with.
By adding AssemblyScript to the mix, we’re making it much easier for JavaScript and TypeScript developers to jump into blockchain development—without losing the speed and power Stylus is known for.
How This Helps the Arbitrum Ecosystem
This upgrade opens the door for thousands of TypeScript and script-based developers to build on Arbitrum. It brings more flexibility and lowers the learning curve for Web3 devs.
We’re aiming to support 90%+ of what the current Stylus SDK can do—so developers still get all the performance benefits, but with a more familiar language.
In short: more devs, building better apps, faster.
What’s Next
We’re kicking things off with technical research and SDK design. After that, we’ll move into development, sharing everything with the community along the way in the Arbitrum DAO forum.
We’ll also track important stuff like how fast the SDK is, how many people use it, and how secure it is—so the whole project stays aligned with the Arbitrum community’s goals.
5 Likes
As a person who uses TypeScript a lot, I appreciate this.
2 Likes
Project Kickoff: Bringing AssemblyScript to Stylus
Over the next few months, the WakeUp Labs team is focused on bringing high-performance smart contracts to developers who already know a Script-based language. This means you won’t need to learn a whole new language from scratch to start building on Arbitrum.
We’re starting with deep research and SDK architecture planning, followed by hands-on development. Everything will be open and documented so the community can follow along.
We’re excited to help more developers join the Web3 movement by making powerful tools easier to use.
Stay tuned for progress updates and key milestones!
2 Likes
WakeUp Labs Completes Key Milestone with Arbitrum: Making Smart Contracts More Accessible with AssemblyScript
TL;DR:
We have successfully completed Milestone #2 in our collaboration with Arbitrum. This milestone focused on feasibility: could AssemblyScript really work within the Stylus framework? Our team dove deep into the Stylus SDK, WebAssembly behavior, and developer tooling. The outcome: a working proof-of-concept, a detailed technical architecture, and a clear path forward.
Why This Matters
Our mission in Milestone #2 was to rigorously analyze whether AssemblyScript — a TypeScript-to-WebAssembly compiler — could be integrated with the Arbitrum Stylus SDK. The goal: enable developers to write Stylus-compatible smart contracts using a familiar, script-like syntax. With so many developers already proficient in JavaScript and TypeScript, AssemblyScript has the potential to broaden participation in smart contract development.
But first, we had to answer a critical question:
Can AssemblyScript work smoothly with Stylus?
To achieve this, we began by researching how AssemblyScript interacts with WebAssembly, focusing on its unique patterns and constraints. We then performed an in-depth analysis of the Stylus SDK to pinpoint the most viable integration points. Based on these insights, we defined the technical requirements needed to create robust AssemblyScript bindings. With those foundations in place, we designed a high-level architecture for the toolchain that outlines how the components would work together. Finally, we built an initial proof of concept to validate the core integration and demonstrate its potential.
What We Deliver
This phase was all about exploring that integration. Here’s what we delivered:
- Feasibility Report. A detailed study of AssemblyScript ↔ WebAssembly interaction challenges and Stylus SDK architecture.
- High-Level Architecture. We mapped out how AssemblyScript bindings would bridge into Stylus, including a modular view of necessary components.
- Roadmap. A technical trajectory covering how we’ll move from research to production-grade tools, with priorities for binding design and dev tooling.
- Initial Proof of Concept. A minimal implementation showing key components of AssemblyScript interacting with Stylus VM — early, but effective.
- A demo — as an example of a successful implementation integrated with Stylus VM.
What’s Next?
With Milestone #2 complete, we’re moving into Milestone #3: Core Development – Setting the Foundation, where we’ll:
-
Build the actual AssemblyScript bindings and SDK-compatible APIs.
-
Set up a dedicated WebAssembly compilation pipeline tailored for AssemblyScript.
-
Begin developing developer-facing utilities for contract compilation and testing.
AssemblyScript offers a TypeScript-like syntax that lowers the learning curve for Web2 developers entering Web3. By bringing this to Stylus, we’re expanding the smart contract developer base — without compromising on performance or safety. It’s a step toward greater inclusivity and innovation in the Arbitrum ecosystem.
Thanks for following along! Don’t forget to connect with us on X (Twitter) and LinkedIn for the latest updates.
Demo Now Live: AssemblyScript + Stylus
We’ve just released a demo showcasing our AssemblyScript integration with the Stylus SDK, part of our ongoing collaboration with Arbitrum. The demo features an ERC-20 smart contract written in AssemblyScript, demonstrating how TypeScript developers can now get closer to onchain deployment using familiar syntax.
Let’s build Arbitrum together! 
Milestone #3 & #4 Completed: Core Development and Feature Implementation
TL;DR:
We’ve completed our third and fourth milestones, pushing AssemblyScript support for Stylus into real development workflows. From APIs and compilation to ERC standards and CLI tooling developers can now start experimenting with AssemblyScript smart contracts on Arbitrum.
What We Achieved
Milestone #3 – Core Development
This phase was focused on laying the technical foundation for AssemblyScript on Stylus:
Built a WebAssembly compilation workflow tailored for AssemblyScript and compatible with Stylus constraints.- Defined early-stage AssemblyScript APIs to expose essential types and contract patterns.
- Delivered a minimal example contract in AssemblyScript to illustrate the development flow.
- Introduced an initial ABI generation process to support tooling compatibility.
Deliverables
As part of this milestone, we focused both on proving the technical workflow and on making the developer experience more tangible. Here’s what we shipped:
Demo
- Example Contract: a minimal smart contract written in AssemblyScript, showing the basic development flow on Stylus.
- ABI Output Tooling: a prototype tool that automatically generates ABI specs from AssemblyScript source.
- Developer Experience: early insights into how the SDK feels to use, including workflow steps and usability notes.
Report
- Compilation Workflow: a detailed overview of the AssemblyScript → WebAssembly → Stylus compilation pipeline.
- Interfaces Definition: documentation of the key design decisions around which types are supported by the AssemblyScript SDK.
Milestone #4 – Feature Implementation
With the core in place, we extended the SDK to cover more advanced use cases and developer experience:
- Added support for essential Stylus SDK features enabling low-level system interactions.
- Expanded the toolchain for WebAssembly-specific requirements.
- ERC-20 compatibility: full implementation for token contracts.
- ERC-721 compatibility: progress toward NFT development workflows.
- Released our first CLI (available on npm) to create, compile, and deploy AssemblyScript contracts.
Deliverables:
- CLI Demo: How to create, compile, and deploy AssemblyScript contracts using the CLI.
- Playground Demo: Interactive environment to experiment with deployed AssemblyScript contracts.
- Developer Documentation: Usage guides, API references, and workflow instructions.
- Developer Playground: A web-based playground where developers can experiment with and interact directly with their AssemblyScript smart contracts.
Useful Links
Why This Matters
AssemblyScript and TypeScript share a familiar syntax, lowering the barrier for thousands of developers to build on Stylus. Bringing this to Stylus makes Arbitrum more accessible while preserving the performance and safety of WebAssembly.
We’ll continue sharing progress as we move into the next milestones. Stay up to date by following us on X (Twitter) and LinkedIn, where we post regular updates, demos, and opportunities to get involved.
1 Like
