Scrypto 101
Everything you need to write your first smart contracts with the safest language in Web3. Free, at your own pace, with a certificate.
The language that DeFi
needed
Scrypto is an asset-oriented language based on Rust, designed specifically for decentralized finance. It eliminates entire categories of vulnerabilities that have caused billions in losses on other blockchains.
Security by Design
In Scrypto, reentrancy attacks, integer overflow, and underflow don't exist. Assets are native engine objects, not simple table records. Vulnerabilities that have caused millions in losses on Ethereum are structurally impossible on Radix.
Asset-Oriented (ROA)
Tokens, NFTs, and badges are physical engine resources. They're not balances in a mapping. You can create, move, burn, and combine them like real objects. This eliminates accounting errors and drastically simplifies smart contract logic.
Blueprints & Components
Contracts are written as Blueprints (templates) and instantiated as reusable Components with their own state. You can publish a Blueprint once and let thousands of developers instantiate it with their own parameters. Code is shared, reused, and monetized with royalties.
Rust-Based
Scrypto is an extension of Rust — one of the safest and most modern programming languages. If you already know Rust, Scrypto will feel natural. Coming from another language, the learning curve is smooth thanks to macros, strong types, and a compiler that guides you.
1 line
vs 50 lines
What requires inheritance, imports, and testing frameworks in Solidity is solved with a single native instruction in Scrypto. Less code = less attack surface.
// Create a fungible token in Scrypto
let my_token = ResourceBuilder::new_fungible(OwnerRole::None)
.metadata(metadata!(
init { "name" => "MyToken", locked; }
))
.mint_initial_supply(1000);// Create an ERC-20 token in Solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract MyToken is ERC20 {
constructor() ERC20("MyToken", "MTK") {
_mint(msg.sender, 1000 * 10**decimals());
}
}
// + deploy script + ABI + testing framework| Feature | Scrypto | Solidity | Move |
|---|---|---|---|
| Asset Model | Native resources (physical objects) | Balance mapping (ERC-20) | Linear resources |
| Default Security | No reentrancy or overflow | Needs manual checks | Partial (Move Prover) |
| Create a Token | 1 line of code | ~50 lines (ERC-20) | ~30 lines |
| Composability | Native atomic (Transaction Manifests) | Cross-contract calls (risky) | Limited across modules |
| Learning Curve | Medium (facilitated Rust) | Low but deceptive | High (new paradigm) |
| Code Reusability | Instantiable Blueprints + royalties | Inheritance (fragile) | Published modules |
| Readable Transactions | Transaction Manifests (no blind signing) | ABI encoding (opaque) | Typed scripts |
From zero to
Mainnet deployment
6 progressive modules. Each with theory, working code examples, and practical exercises you can run directly with resim.
Introduction to Scrypto 101
Welcome to the course, introduction to the Scrypto language and its ecosystem. Learn the fundamental concepts before writing your first line of code.
Getting Started with Scrypto
Learn the Scrypto package structure, Blueprint anatomy, how to compile, publish and run your first Hello Blueprint, and component modules.
Resources
The heart of Scrypto: fungible and non-fungible resources, behaviors, ResourceManager, containers, NFTs, and how to build a token sale from scratch.
Auth
Master the Radix authentication system: badges, proofs, AccessRules, AuthZone, system-level and application-level auth, and build a decentralized exchange.
Transactions
Understand transactions on Radix with the Transaction Manifest: its structure, anatomy, and practical use to interact with components securely and transparently.
Build Your First Blueprint
Put everything into practice: complete the Escrow challenge, receive feedback, and get your Scrypto 101 course completion certificate.
Frequently Asked
Questions
Who is this course for?
This course is for anyone with minimal experience in programming and is interested in learning how to build the future of Web3. A little bit of knowledge in Web3 and the crypto space could be helpful but it is not necessary.
Do I need to know Rust?
Scrypto was built as a Rust framework and adds functionality to natively work with assets. This means that knowing the basics of Rust is a requirement before you get started with this course. Note that only the basics are required as you will not use the more advanced Rust concepts often when writing Scrypto code.
How long is the course?
This course is meant to teach you the basics of Scrypto and how to start using it to prototype your ideas. We estimate it takes about 20 hours to complete or about two weeks if you are advancing a little bit every day.
Do I get a Scrypto certificate?
Yes, you will receive a certificate upon receiving passing grades in the exam.
Is it free?
Absolutely. Scrypto 101 is completely free. You just need to register at the Radix Academy to track your progress and get your certificate upon completion.
Build the future of
decentralized finance
Register for free in the Scrypto 101 course, join the Dev Program, and start building dApps that will change the global financial system.