WTF-Solidity: a 57-lesson Solidity course you read in the repository

What WTF-Solidity is, and the reader it assumes

The README opens by saying the author was relearning Solidity and wrote a "WTF Solidity极简入门" (minimal introduction) for beginners, with a note that experienced programmers should look elsewhere. That framing matters: this is a course written by someone working through the language, published as it was written, not a reference manual assembled after years of production use.

The audience is narrow and stated. You are expected to be new to Solidity but not new to programming, because the lessons move from value types to delegatecall and proxy upgrade patterns in fifty-seven steps. Someone who has never written a function in any language will find the early lessons thin on the basics of programming itself. Someone who has shipped JavaScript or Go will find the pacing reasonable.

The repository is organised as one folder per lesson, numbered from 01_HelloWeb3 through 57_Flashloan. Each folder holds the contract code, and each lesson has a companion article linked from the README, so the unit of study is a folder plus a markdown page. The README groups the lessons into three tiers: 入门 (basics, lessons 1 to 15), 进阶 (intermediate, lessons 16 to 30) and 应用 (applications, lessons 31 onward).

How the repository is laid out, and what each lesson folder contains

The top-level entries include the numbered lesson folders plus .github/, .gitignore and .codespellignore.

The README lists each lesson as a code link and an article link. Lesson 1 is "三行代码HelloWeb3" (three lines of code, HelloWeb3), lesson 27 is ABI encoding and decoding, lesson 46 is a proxy contract, and lesson 57 is a flashloan. Applications include ERC20, ERC721, ERC1155, a faucet, an airdrop, a Dutch auction, a Merkle tree claim, signature verification, an NFT swap, WETH, payment splitting, token vesting and locking, timelocks, multisig, ERC4626, EIP712, ERC20Permit, a cross-chain bridge, multicall and a DEX.

Because the folders are self-contained, you can jump straight to a topic. If you only care about upgradeable contracts, lessons 46 through 49 cover the proxy contract, the upgrade, the transparent proxy and UUPS. That is a real advantage over a linear video course, and it is a direct consequence of the folder-per-lesson layout.

Installing nothing: opening your first lesson in Remix

The README points at code and articles. The practical path is to open the lesson's contract file from the repository and paste it into a browser Solidity IDE such as Remix. Nothing in the repository needs to be cloned to follow along, though cloning gives you every lesson offline.

Start with lesson 1. The README describes it as three lines of code, and the file lives at 01_HelloWeb3/.

From there, the lessons follow the numbering. Lesson 2 covers value types, lesson 3 covers function visibility and mutability (external, internal, public, private, pure, view, payable), and lesson 5 covers storage, memory and calldata. Each article explains the mechanism, then the folder holds the contract that demonstrates it. If you want the whole set locally, git clone the repository and open the folders in your editor.

Where the course stops being enough

The lessons are teaching artefacts, not audited production code. A Dutch auction in lesson 35 or a flashloan in lesson 57 demonstrates a mechanism; the README does not claim any of it is safe to deploy with real funds. Reading lesson 44 on token locking does not make you qualified to lock someone else's tokens.

The language coverage is uneven in a way the README is honest about but does not fix. The root README is in Chinese, and the header links to an English README under Languages/en/, a Spanish one under Languages/es/ and a Brazilian Portuguese one under Languages/pt-br/. The root-level lesson list is the Chinese one. If you follow the English README you are reading a translation, and translations of a weekly-updated course lag. The README says the author updates one to three lessons per week, which means the newest lesson may exist in Chinese only for a while.

Finally, the course is Solidity-specific and Ethereum-specific in its examples. If your target is a non-EVM chain or Vyper, the contract patterns here transfer only partially, and the tooling assumptions (Remix, EVM opcodes, gas) do not transfer at all.

WTF-Solidity versus Solidity by Example and the official docs

The closest comparison is Solidity by Example, which is also a code-first collection of small contracts. The difference is structure. Solidity by Example is organised by topic and is largely a set of annotated snippets. WTF-Solidity is organised as a numbered course with a stated order and a stated audience, and each lesson pairs a contract with a written article of some length. If you want to look up how a mapping works, the snippet collections are faster. If you want to be walked from value types to a proxy upgrade in sequence, the numbering here does the sequencing for you.

The other comparison is the official Solidity documentation. The docs are the authority on language semantics and are versioned against the compiler; WTF-Solidity is a third-party teaching layer over that, and it will always be behind the compiler on new features. Use the docs to confirm what a keyword actually does, and use this repository to see it used in a small contract.

There is also a course component outside the repository. The README points at wtf.academy for the site and a Learning Center for course certification via an SBT, and it lists a Discord server and a WeChat group. Those are separate from the repository content, and the repository itself is the part you can read and run without signing up for anything.

Maintenance, licence and what a fork costs you

The last push was on 2026-10-11, and the repository is not archived. That is recent enough that the course is being extended rather than abandoned, and the README's stated cadence of one to three lessons per week is consistent with a repository that still receives commits. There are no releases, so there is no versioned artefact to pin; you track the main branch or you pin a commit yourself.

Upgrade cost is low in the sense that nothing is installed and nothing breaks when the repository changes. It is higher in the sense that lesson content can be edited under you, and a contract you copied into a project last year may no longer match the article that explained it. If you are using a lesson as a starting point for real code, copy the contract into your own repository and pin the compiler version there rather than re-reading the lesson folder.

The licence is reported as NOASSERTION, which means GitHub could not match the repository's licence file to a known identifier. If you intend to reuse the code commercially, treat the licensing as unresolved and ask the maintainer.

Editorial conclusion

Adopt WTF-Solidity if you already read code comfortably and want a short, numbered path from value types to flashloans, with each lesson's contract sitting next to its article. Do not adopt it if you need a graded curriculum with exercises, autograding or instructor support, because the repository supplies code and prose, not assessment. Before committing study time, open 01_HelloWeb3 and 57_Flashloan, confirm the Solidity pragma each lesson targets, and check which of the three translated READMEs matches your language, since the English README lives under Languages/en rather than at the repository root.

Frequently asked questions

Official sources

1. AmazingAng/WTF-Solidity on GitHub
2. Issues
3. Project website
4. README