# WTF Solidity: A Progressive Tutorial for Learning Solidity from Basics to DeFi Contracts

> WTF Solidity is an open-source tutorial repository with over 57 lessons organized into beginner, intermediate, and application tiers. It is built for developers who want a structured introduction to Solidity, with Chinese as the primary language and English lessons available via the Languages directory.

**AmazingAng/WTF-Solidity** — WTF Solidity 极简入门教程，供小白们使用。Now supports English! 官网: https://wtf.academy

- Repository: https://github.com/AmazingAng/WTF-Solidity
- Website: https://wtf.academy
- Stars: 14,061 · Forks: 2,437
- Language: Solidity
- License: NOASSERTION
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/amazingang-wtf-solidity

## A Three-Tier Curriculum from Hello World to DeFi Mechanics

WTF Solidity organizes its lessons into three explicit tiers: beginner, intermediate, and application. The beginner tier covers lessons 1 through 15 and addresses the language's foundational constructs: value types, functions (with all visibility and state mutability modifiers including external, internal, public, private, pure, view, and payable), returns and named return values, storage locations (storage, memory, calldata), arrays, structs, mappings, variable initial values, constants, immutables, control flow, constructors, modifiers, events, inheritance, abstract contracts, interfaces, and error handling. That is a complete introduction to the Solidity type system and contract structure in 15 lessons.

The intermediate tier runs from lesson 16 through 30. It covers function overloading, library contracts, the import statement, receiving ETH via fallback and receive functions, sending ETH through transfer, send, and call, calling other contracts, the low-level call and delegatecall, factory patterns using the Create and Create2 opcodes, contract deletion, ABI encoding and decoding, hashing with keccak256, function selectors, and try-catch for external call error handling. This tier is where Solidity's more unusual behaviors (delegatecall storage layout, Create2's address determinism, selector encoding) appear.

The application tier starts at lesson 31 and covers real contract patterns: ERC20 fungible tokens, a faucet contract, an airdrop contract, ERC721 NFTs, a Dutch auction, a Merkle tree-based allowlist, digital signatures, an NFT exchange, randomness, ERC1155 multi-token, WETH, payment splitting, token vesting, token locking, a timelock, proxy contracts (transparent and UUPS), a multisig wallet, ERC4626, EIP712 typed signatures, ERC20Permit, a cross-chain bridge, MultiCall, a DEX, and a flash loan. The README lists at least 57 numbered lesson directories in the top-level repository.

## Repository Structure: One Directory Per Lesson with Code and Explanation Paired

Each lesson in WTF Solidity lives in its own numbered directory. Lesson 1 is 01_HelloWeb3/, lesson 2 is 02_ValueTypes/, and so on through 57_Flashloan/ and beyond. Inside each directory, the README links to two resources: the lesson's Solidity source code file and a written explanation article. This pairing means every concept comes with both a minimal contract to read and a prose explanation of why it works the way it does.

The lesson numbers correspond directly to learning order. A developer starting from scratch works through the directories in sequence. The numbering also acts as navigation: someone who already knows Solidity basics but wants to understand flash loans can go directly to 57_Flashloan/ without reading the preceding tiers. The README serves as a table of contents with links rather than inline content, keeping the top-level file short and the lesson content self-contained.

The top-level repository also contains a .github/ directory for CI configuration, a .codespellignore for typo checking, a .gitignore, and language directories. The Languages/ directory holds the English version of the curriculum. According to the README header, the English translation is linked as a parallel resource: 'English' and 'Español' and 'Português Brasileiro' are listed at the top of the README alongside the primary Chinese content. The English lessons live under Languages/en/.

The repository does not include a development environment setup, a package.json, or toolchain configuration at the top level. It is a curriculum to read, not a project to build. Each lesson's Solidity file is a standalone contract; the README does not document a specific Solidity compiler version or toolchain requirement.

## The Application Tier: Real Contract Patterns Beyond Language Basics

The application tier is the section most relevant to developers who already know Solidity syntax and want to understand how production contracts work. Starting at lesson 31, the curriculum shifts from language mechanics to contract architecture.

The ERC20 lesson (31) and ERC721 lesson (34) implement the full token standards. Lessons 46 through 49 cover proxy contracts in depth: the base proxy pattern, the upgrade mechanism, the transparent proxy pattern, and the UUPS (Universal Upgradeable Proxy Standard) pattern. These are architecturally distinct and represent the main approaches teams use to make deployed contracts updatable. The README does not explain the differences between transparent and UUPS proxies in the table-of-contents listing; that detail lives in each lesson's article.

Lesson 50 covers a multisig wallet, lesson 54 covers a cross-chain bridge, lesson 56 covers a DEX, and lesson 57 covers a flash loan. The flash loan lesson represents the ceiling of the curriculum in terms of contract complexity. Flash loans are a mechanism specific to DeFi where a contract can borrow and repay within a single transaction, with the entire sequence atomically reverting if repayment fails. This is a pattern that does not exist in general-purpose programming and requires understanding Solidity's transaction semantics.

The application tier lessons are where the earlier intermediate-tier content (delegatecall, Create2, ABI encoding, function selectors) becomes meaningful in context. A developer who works through the tutorial in order will encounter those intermediate-tier mechanisms again in the application contracts where they are actually used.

## wtf.academy, Certification, and the Community Infrastructure

The repository connects to an official companion site at wtf.academy. The README marks the site launch as one of the project's development milestones. The wtf.academy platform offers a Learning Center at wtf.academy/courses with on-chain SBT (Soulbound Token) certification. SBTs are non-transferable NFTs that record course completion permanently on the blockchain; they cannot be sold or transferred after being issued, which distinguishes them from ordinary NFTs.

The README also lists community infrastructure: a Discord server and a WeChat group (via a Google Forms signup link). Both are listed alongside the early development milestones as community-building goals. The Discord link points to discord.gg/5akcruXrsk.

The README roadmap is structured around milestone targets, with each milestone tied to a development goal. Building a community was milestone 64, producing advanced content was milestone 256, launching the official site was milestone 512, and issuing course certification SBTs was milestone 1024. A community NFT is listed as an upcoming milestone at 2048. This roadmap structure makes the project's development history readable directly from the README without external context.

The project operates with a stated update cadence of one to three lessons per week, as written in the README introduction. The last push was on 2026-09-27, which is consistent with an active update cycle. The repository has no GitHub releases; lesson content ships directly to the main branch.

## What This Tutorial Does Not Cover

WTF Solidity covers Solidity as used on EVM-compatible blockchains. It does not address non-EVM smart contract environments such as those based on WebAssembly runtimes or other virtual machine architectures. Developers targeting chains with non-EVM smart contract models will need resources specific to those environments.

The tutorial does not cover Vyper, the alternative Python-influenced smart contract language used on Ethereum. Whether Vyper is a better choice than Solidity for a given project is a design question the README does not address. The two languages have different safety tradeoffs (Vyper restricts certain features Solidity allows, such as function overloading and inline assembly), but the curriculum takes Solidity as its subject without comparing the two.

Formal verification, symbolic execution, and security auditing tools are not covered. Lesson 15 covers Solidity's built-in error handling (errors, require, assert, revert), and the intermediate tier covers potential misuse patterns such as delegatecall storage layout, but a systematic treatment of smart contract security auditing is outside this tutorial's scope. Developers building contracts that will hold significant funds should supplement this tutorial with dedicated security resources.

The README does not document which Solidity compiler version the lessons target, nor does it list a recommended development environment. Developers new to the toolchain (Hardhat, Foundry, or Remix IDE) will need to find that setup information elsewhere. The README links to individual lesson code files but does not provide a project-wide build configuration.

## Is Solidity Hard to Learn and How WTF Solidity Addresses That

Solidity is harder to learn than a general-purpose language like Python primarily because it introduces two compounding difficulties at once: an unfamiliar execution environment and an unfamiliar set of failure consequences. Smart contracts execute on a public blockchain where every state change is permanent and all deployed bytecode is visible. A mistake that would cause a runtime exception in Python can drain a contract's funds in Solidity. That context raises the cost of misunderstanding any language feature.

WTF Solidity addresses this by sequencing the curriculum so that storage locations (lesson 5), modifiers (lesson 11), and error handling (lesson 15) appear early, before the application-tier contracts where these features interact in more complex ways. The README's stated audience is beginners ('小白们'), and the lesson ordering reflects that: control flow and insertion sort appear at lesson 10, before inheritance at lesson 13, before events at lesson 12 in the README listing (the numbering follows the lesson title, not the order topics would appear in a language reference).

The pairing of code and article in each directory reflects a pedagogical choice. An article can explain intent and common mistakes in prose; a code file provides a minimal reproducible example. Reading both together gives a learner more context than either alone. Whether this approach is sufficient for a learner who has never written a deployed contract depends on whether they have access to a development environment where they can deploy test contracts and observe their behavior. The repository does not provide that environment setup.

## Conclusion

Developers who want a structured, progressive introduction to Solidity and EVM-compatible contracts will find WTF Solidity well-organized, with content that extends from three-line HelloWeb3 contracts through ERC-721 NFTs, upgradeable proxies, DEX implementations, and flash loans. Developers who need coverage of non-EVM blockchains, formal verification, or Vyper should look elsewhere since the tutorial does not address those topics. The free tier covers all lesson content on GitHub and the wtf.academy platform; on-chain SBT certification is available through the Learning Center at wtf.academy/courses. The repository was last pushed on 2026-09-27.

## FAQ

### Is Solidity hard to learn for someone coming from Python or JavaScript?

Solidity's syntax is closer to JavaScript than Python, but the execution model differs significantly: state changes are permanent and on-chain, gas costs constrain what contracts can compute, and storage layout affects correctness in ways that have no equivalent in general-purpose languages. WTF Solidity introduces storage locations and error handling early in the curriculum to address these differences directly.

### Does WTF Solidity cover both Chinese and English?

The primary curriculum is in Chinese, and the README lists English as an available language under a Languages/en/ directory. Spanish and Brazilian Portuguese are also listed. The main README and lesson files default to Chinese.

### What certification does wtf.academy provide for completing WTF Solidity lessons?

The wtf.academy Learning Center at wtf.academy/courses offers SBT (Soulbound Token) certification, which are on-chain non-transferable tokens that record course completion. SBTs cannot be sold or transferred after issuance.

## Sources

- [AmazingAng/WTF-Solidity on GitHub](https://github.com/AmazingAng/WTF-Solidity)
- [Issues](https://github.com/AmazingAng/WTF-Solidity/issues)
- [Project website](https://wtf.academy)
- [README](https://github.com/AmazingAng/WTF-Solidity/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/amazingang-wtf-solidity