Skip to content

Conversation

@anegg0
Copy link
Contributor

@anegg0 anegg0 commented Nov 14, 2025

WIP PR:

  • Content restructuring
  • Update content to stylus-sdk-rs v0.1
  • Fix NavBar's display error

The proposed temporary structure is the following:

  • Gentle Introduction
  • Stylus SDK (Rust)
  1. Getting Started
    1. Installation
    2. Hello World
    3. Hello, Cargo Stylus
  2. First App Example (Counter or Vending Machine)
  3. Structure of a Stylus contract
    1. Project layout
    2. Variables
    3. Functions
    4. Modules
    5. Importing packages
    6. Events
    7. Errors
  4. Data Types
    1. Primitives (include Sol & Rust primitives where applicable)
      1. Boolean
      2. Integers
      3. Address (include AddressVM traits from types module)
      4. String
        1. Literals
        2. Hex
    2. Compound types
      1. Tuple
      2. Struct
      3. Array
      4. Vector
      5. Bytes
      6. FixedBytes
    3. Storage
      1. Bool
      2. Uint
      3. Address
      4. Struct
      5. Array
      6. Map
      7. String
      8. Bytes
      9. FixedBytes
    4. Conversions Between Types
  5. Global variables and functions
    1. block
    2. contract
    3. crypto
    4. EVM
    5. msg
    6. tx
    7. debug
  6. Contracts
    1. Calling other contracts
      1. Call
      2. Raw call
      3. Delegate call
      4. Static call
      5. sol_interface
    2. Sending ETH
    3. Factory deploy
    4. Function modifiers
    5. Inheritance (temporary)
    6. Constructors (coming soon)
  7. Writing tests (coming soon)
  8. Advanced
    1. Solidity differences
    2. Recommended packages
    3. Minimal entrypoint contracts
    4. Hostio exports
  9. FAQs
  • Using the CLI
    • Check and deploy
    • Verify contracts
    • Exporting ABI
    • Debugging with replay
    • Optimizing WASM binary size
    • Deploying non-Rust WASM contracts
  • VM Concepts
    • WebAssembly
    • EVM differences
      • Size limits
      • Ink and gas
      • Memory and compute
    • Activation
    • Caching strategy
  • Stylus by Example (external link)
  • Rust crate docs (external link)
  • Source code repository (external link)

Add lint:markdown:fix to the format script to automatically fix
markdown linting issues when running yarn format. This ensures
markdown files are both formatted (prettier) and linted (markdownlint)
in one command.

The new format workflow:
1. Format docs with prettier
2. Format app files with prettier
3. Auto-fix markdown linting issues
4. Verify all files pass prettier check
@vercel
Copy link

vercel bot commented Nov 14, 2025

The latest updates on your projects. Learn more about Vercel for GitHub.

Project Deployment Preview Updated (UTC)
arbitrum-docs Ready Ready Preview Nov 29, 2025 0:20am

@joshuacolvin0 joshuacolvin0 changed the title Stylus v0.1 Stylus v0.10 Nov 20, 2025
Add detailed documentation for all Stylus SDK primitive types including:
- Boolean (bool) with usage examples and Solidity mappings
- Unsigned integers (u8-u128, U256, Uint<BITS, LIMBS>)
- Signed integers (i8-i128, I256, Signed<BITS, LIMBS>)
- Address type with constants and validation examples
- String type with literal and formatting examples
- Bytes types (dynamic Bytes and fixed FixedBytes<N>)
- Hex literal usage examples
- Complete type mapping tables for all primitives
- Best practices for each primitive type
- Type conversion examples

Each section includes:
- Practical code examples
- Solidity type mappings
- Storage size information
- ABI signature details
- Common usage patterns
Add detailed documentation for all Stylus SDK compound types including:
- Tuples with destructuring and pattern matching examples
- Structs using sol! macro with AbiType derivation
- Nested structs for complex data structures
- Fixed-size arrays with iteration and operations
- Vectors (dynamic arrays) with filter, map, and fold operations
- Bytes types (dynamic Bytes and fixed FixedBytes<N>)
- Complete type mapping tables for all compound types
- Best practices for each compound type
- Type conversion helpers and iterator patterns
- Common patterns (batch operations, pagination)

Each section includes:
- Practical code examples from SDK examples
- Solidity type mappings
- ABI signature details
- Memory and gas efficiency considerations
- Complete working examples with nested structures
- Iterator and functional programming patterns
Add comprehensive documentation comparing EVM and Nitro WASM VM. Covers:

- Execution model differences (stack-based vs register-based)
- Memory model (32-byte chunks vs 64KB pages)
- Gas metering with ink system and conversion formula
- Instruction sets (EVM opcodes vs WASM instructions)
- Size limits (24KB for both with optimization notes)
- Storage model compatibility and caching benefits
- Performance characteristics (10-100x cheaper compute)
- Call semantics and interoperability examples
- Contract lifecycle (deployment, activation, execution)
- Developer experience comparison
- Feature compatibility matrix
- State sharing across VMs
- Gas economics and cost structures
- Best practices for each environment
- Hybrid approach strategies
- Migration considerations from Solidity to Stylus
- Future developments for both platforms

Includes practical examples of:
- Memory growth with pay_for_memory_grow
- Storage caching in Stylus
- Cross-VM contract calls
- Hybrid contract architectures

Based on stylus-sdk-rs implementation including hostio.rs,
entrypoint.rs, host.rs, and SDK examples showing WASM execution
patterns compared to traditional EVM operations.
Add detailed documentation covering WASM basics in the context of Arbitrum Nitro and Stylus:
- WASM fundamentals and why it's used in Nitro
- Compilation target (wasm32-unknown-unknown) configuration
- Binary structure (exports, imports, memory, custom sections)
- Compression with brotli and 0xEFF000 prefix
- Contract activation process and caching
- Development workflow and best practices
- Size limitations and optimization strategies
- Memory model and supported WASM instructions
Add buildSoliditySidebar and buildStylusSidebar to provide focused
navigation experiences. Each sidebar contains only its relevant content
category, eliminating the need for collapse/expand behavior.
Change displayed_sidebar frontmatter from buildAppsSidebar to
buildSoliditySidebar for all Solidity documentation pages.
Change displayed_sidebar frontmatter from buildAppsSidebar to
buildStylusSidebar for all Stylus documentation pages.
Add detailed documentation for validating and deploying Stylus contracts:
- Prerequisites and setup requirements
- Two-step deployment process (deploy + activate)
- cargo stylus check command with validation details
- cargo stylus deploy command with all options
- Activation process and data fee calculation
- Development and production workflows
- Best practices for secure deployment
- Comprehensive troubleshooting section
- Non-Rust WASM deployment support
- Command reference and examples
Add detailed documentation for exporting Solidity ABIs from Stylus contracts:
- Overview of ABI generation process
- Basic usage of cargo stylus export-abi
- Solidity interface and JSON format output
- Writing ABI-compatible contracts with #[public] macro
- Function visibility mapping (view, pure, payable)
- Type mapping between Rust and Solidity
- Custom errors and events
- Trait implementation and interface inheritance
- Constructor signature export
- Front-end integration (ethers.js, viem, wagmi)
- Solidity contract integration
- Export configuration options
- Best practices for ABI management
- Troubleshooting common issues
- Multi-contract workspace support
Add detailed documentation for deploying WebAssembly contracts from languages other than Rust:
- Overview of non-Rust WASM deployment with --wasm-file flag
- When to choose non-Rust vs Rust (use case comparison)
- WASM module requirements (exports, imports, memory)
- WebAssembly Text (WAT) examples (minimal, echo, counter)
- C/C++ development with Stylus C SDK
- C SDK features and building with Makefile
- Cryptography example in C
- AssemblyScript contract development
- Complete deployment workflow (prepare, optimize, check, deploy)
- Best practices for size optimization and memory management
- Troubleshooting common issues (entrypoint, imports, memory, size)
- Language support matrix (Rust, C/C++, WAT, AssemblyScript, etc.)
- Advanced custom language integration guide
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

slop starter Generated draft to start from

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants