Are you looking for Ethereum Virtual Machine (EVM) Tutorials to build your next dApp with Solidity, Vyper or Yul? The following resources cover everything you need to know about Ethereum, Smart Contracts and the Ethereum Virtual Machine (EVM).

Browse the best Ethereum Virtual Machine (EVM) Tutorials that will teach you Solidity, Vyper and more.

Ethereum Virtual Machine Tutorials

The "DappUniversity" YouTube Channel is a great place to find useful video tutorials for full-stack dApp development on Ethereum. Simply click on the "Playlists" tab to find curated lists with videos on topics such Solidity, Web3.js, Ethereum + React and more.
Protip: When sorting the videos by duration you'll find a bunch of long-form videos (some of which are ~8 hours long!) which will walk you through the whole dApp development life cycle end-to-end. Also keep an eye on the video descriptions which usually include links to the project's GitHub repository.

Tutorials, guides and courses to master Blockchain development.

DappUniversity

The "EatTheBlocks" YouTube Channel is another great resource to learn Smart Contract and dApp development on the Ethereum Blockchain. The channel is very developer-focused and covers a wide range of topics such as Solidity, Web3.js, OpenZeppelin, Money Legos (DeFi), UI / UX and more. Clicking on the "Playlists" tab will show you curated lists of videos from such topics.
Protip: The <a href="https://github.com/jklepatch/eattheblocks">eattheblocks GitHub</a> repository is the central place where all the channels code is published and released. In it you'll find projects for topics such as Flash Loans, ERC-20 Tokens, DEXes and more.

Videos to learn Blockchain- and Smart Contract development.

EatTheBlocks

The "Smart Contract Programmer" YouTube Channel is a hands-on resource that teaches you everything you need to know to become a proficient Smart Contract developer.
Topics covered are Solidity- and Vyper basics, Smart Contract security and hacks, dApp development, engineering best practices and Smart Contract composability (via DeFi protocol integrations).

Hands-on tutorials and explainers to learn Smart Contract development on Ethereum Virtual Machine (EVM) chains.

Smart Contract Programmer

Browsing through Yos Blog you'll find very useful in-depth articles about Ethereum and Smart Contract development with Solidity.
Topics covered are Smart Contract testing and development best practices, Decentralized Finance (DeFi) with its underlying algorithms and economics as well as Web 3 in general.

In-depth articles on Ethereum, Smart Contract Development and Blockchain-related topics.

Yos Riady's Blog

Eth.build is an educational sandbox which helps you understand how Ethereum works via visual exploration. Be sure to check out the <a href="https://www.youtube.com/watch?v=30pa790tIIA">video introduction</a> which explains everything in great detail.

Sandbox to visually explore how Ethereum works under the hood.

Eth.Build

The EthSpring project is an effort to gather and categorize Ethereum learning resources. Browsing through their material you'll learn about the Crypto Philosophy, Peer Protocols, Protocol Theory, Zero-Knowledge-Proofs and more.
Protip: You can also subscribe to the EthSpring Newsletter to get notified when new resources are added.

Collection of various Ethereum learning resources.

EthSpring

The Solidity Patterns project is an effort to consolidate the best design- and programming patterns for Smart Contract projects written in Solidity. Browsing through it you'll find patterns from categories such as behavior, security, upgradeability and economics.
Note: While the document refers to Solidity version 0.4 most of the patterns can be applied without any strict version requirement.

Compilation of Solidity Patterns and Best Practices.

Solidity Patterns

This blog post written by Nader Dabit teaches you everything you need to know to build and launch your own EVM-based NFT Marketplace.
Working through it you'll use technologies like Next.js, Tailwind CSS, Solidity, Hardhat, Ethers.js and IPFS to create your own ERC-721 Smart Contract, publish the NFT to IPFS and display it via a frontend written in React.
The codebase for the project can be found on <a href="https://github.com/dabit3/polygon-ethereum-nextjs-marketplace/">GitHub</a>. If you're a visual learner you can check out the accompanying <a href="https://www.youtube.com/watch?v=GKJBEEXUha0">YouTube video</a>.

Learn how to build your own NFT Marketplace from scratch.

Building a Full Stack NFT Marketplace

The "Generating Dynamic NFTs On-chain Tutorial" by Nader Dabit teaches you everything you need to know to create your own generative art NFT project.
During the course of this ~1 hour tutorial you will write your own ERC-721 contracts in Solidity and learn how you can use Chainlink's VRF (Verifiable Random Function) Oracle to introduce a trustworthy source of randomness.

How to generate dynamic NFTs stored as on-chain data.

Generating Dynamic NFTs On-Chain

This step-by-step video tutorial by the HashLips NFT project teaches you how to build and deploy a full-stack, EVM-based NFT game with Solidity.
The codebase for the project can be found on <a href="https://github.com/HashLips/nft_game">GitHub</a>.

HashLips NFT Game Tutorial

The NFT School is a community-driven website dedicated to cover all aspects of NFTs. Browsing through it you'll find resources to learn basic NFT concepts, in-depth tutorials as well as references and recommendations.
NFT School is an Open Source project so everyone is encouraged to update the website and contribute to the project.

Community for NFT developers and collectors.

NFT School

OpenSea's Non-Fungible Token Bible is a long-form blog post that covers everything you need to know about NFTs.
Reading through it you'll learn the basics of NFTs, differences between token standards like ERC-721 and ERC-1155, the history of NFTs as well as background information about the Non-Fungible Token market.

Learn everything you need to know about NFTs.

The Non-Fungible Token Bible

<h2>Getting Started</h2>
<h3>0. Learn JavaScript Basics (Optional)</h3>
A typical dApp is a combination of a Frontend (what the user sees and interacts with) and a Backend (usually your Smart Contracts deployed on the Ethereum Blockchain).
Given that Frontends as well as the vast majority of Ethereum's Smart Contract development tooling is written in JavaScript it's a worthwhile endeavour to brush up your JavaScript skills before diving deeper into Solidity and dApp development. If you're new to JavaScript or need a quick refresher you'll find a good resource in the <a href="https://www.codecademy.com/learn/introduction-to-javascript">Learn JavaScript</a> course by Codecademy.
Protip: Don't spend too much time on intermediate and advanced topics. Knowing the basics of JavaScript should be more than enough to get you going.
<h3>1. Work through CryptoZombies</h3>
The best way to learn something new is through a structured curriculum which walks you through the big ideas and major concepts in a guided fashion. Ideally as frictionless as possible.
<a href="https://cryptozombies.io/">CryptoZombies</a> is one of the best resources for every aspiring Ethereum dApp / Solidity developer. In it you'll build your own NFT-style Zombie game and learn all the important concepts of EVM development and the Solidity programming language. The best part is that it's completely browser based, so you don't need to install and configure anything.
While you can work through the whole course we'd advice to focus on the first 2 sections about Solidity Smart Contract development.
If you're interested in writing Smart Contracts with Vyper you should check out <a href="https://vyper.fun/">Vyper.fun</a> which is another great interactive resource focused on the Vyper programming language.
<h3>2. Learn about Truffle Suite / Hardhat</h3>
While you can install and setup all the different toolings such as a Solidity / Vyper compiler from scratch doesn't mean you should.
Luckily enough others jumped in and built whole developer tool suites such as the <a href="https://www.trufflesuite.com/">Truffle Suite</a> or <a href="https://hardhat.org/">Hardhat</a>. Take some time to browse through both projects and play around with their solutions.
Once you're familiar with both, pick your favorite development stack and stick with it (at least for the time being). For beginners Truffle is usually the best choice as it comes with "batteries included". Intermediate / Advanced users will find more flexibility in Hardhat.
<h3>3. Build your first dApp</h3>
Given that you're now familiar with some basic Solidity / Vyper and the developer toolings in the Ethereum dApp space it's time to work on your first "real" project.
If you're already familiar with Software- and JavaScript development in general you might want to jump straight into your own first project without any further guidance.
For others, it might be worthwhile to follow an online tutorial like <a href="https://www.dappuniversity.com/articles/the-ultimate-ethereum-dapp-tutorial">this one</a> from "Dapp University".
It isn't super important what you're building as long as you focus your efforts on writing code, rather than consuming more blog posts and YouTube videos.
<h3>4. Build more dApps</h3>
Once done with your very first dApp, you surely ran into various roadblocks you didn't anticipate beforehand. While having guardrails in the beginning is a necessity, it's being on your own where true growth happens and the learnings materialize.
Given that, you should spend some more time building dApps end-to-end. This time around without any guardrails. Start with a clean slate and work your way through the whole process. Start with the Smart Contract logic, connect it to a frontend and ensure that everything works by writing unit- and integration tests.
It's absolutely ok to check references and existing code to get you unstuck but focus on trying to solve the problem on your own before consulting other resources.
"What should I build?". That's a common and valid question given that we should be focusing on deliberate practice rather than rote repetition. The following is a list of dApp ideas you can draw from (ordered by difficulty: Easy - Hard):
<h4>Voting (Easy)</h4>
A voting dApp where users can vote for candidates. Every user should only be able to vote once.
<h4>CRUD (Easy)</h4>
A CRUD (Create, Read, Update, Delete) dApp where users can create posts, read posts, update existing posts and remove posts. You should track the ownership of posts such that only owners can update and remove posts.
<h4>Escrow (Medium)</h4>
Write an escrow Smart Contract which helps users facilitate transactions. User A should be able to deposit funds in the Smart Contract while user B should be able to withdraw the previously deposited funds from user A.
You can add a timelock-like feature where funds will be automatically sent back to the depositor after a certain number of blocks has been mined and the funds haven't been withdrawn by user B.
<h4>Lottery (Medium)</h4>
Create a Lottery dApp where users can buy tickets to participate. The money they spent on the tickets is added to a pool. After a pre-defined number of blocks has been mined, a winner is chosen randomly who receives all the funds from the pool.
Note: You can use a simple random number generation schemes derived from block hashes. There's no need to integrate a VRF via an Oracle (although you might want to try that as well).
<h4>Multi-Sig Wallet (Hard)</h4>
Implement a Multi-Sig Wallet where multiple signatures are necessary to create a transaction and spend coins.
<h4>Payment Channel (Hard)</h4>
Implement a payment channel which coordinates transactions between user A and user B off-chain and settles them on-chain. To keep it simple you can start with a Uni-directional Payment Channel and extend it later on to be Bi-directional.
<h4>Flash Loans (Hard)</h4>
Implement a Flash Loan strategy in which you borrow funds, exploit an arbitrage opportunity and repay the borrowed funds while pocketing the difference, all within one transactions.
To help you get started with this one you might want to read how Flash Loans work by reading through the <a href="https://money-legos.studydefi.com/">Money Legos</a> project documentation for the <a href="https://money-legos.studydefi.com/#/aave?id=flashloans">Aave</a> and <a href="https://money-legos.studydefi.com/#/dydx?id=flashloans-on-dydx">dYdX</a> DeFi protocols.
Also learn about "Mainnet Forking" capabilities of Ganache CLI and Hardhat Network. That way you don't need to continually re-deploy your Smart Contract on a testnet.
Protip: It's more than enough to build 2-3 dApps end-to-end. Move on to the next step the minute "everything clicks".
<h3>5. Learn to use OpenZeppelin's Smart Contracts</h3>
Writing secure Solidity / Vyper code can be a tough endeavour. Luckily the folks at OpenZeppelin created and maintain a <a href="https://github.com/OpenZeppelin/openzeppelin-contracts">GitHub repository</a> with audited Smart Contract building blocks you can incorporate in your projects.
The full documentation for all the different Smart Contracts can be found <a href="https://docs.openzeppelin.com/contracts">here</a>.
<h3>6. Get to know ERC standards</h3>
<a href="https://eips.ethereum.org/erc">ERC's</a> are Ethereum Improvement Proposals in which different ideas to improve the Ethereum Blockchain are discussed. One of the most famous ERC's are ERC-20 and ERC-721, both of which describe Token standards.
Read through the ERC-20 and ERC-721 standards and build a dApp which leverages those.
Protip: OpenZeppelin's Smart Contracts package should help you in doing so.
<h3>7. Learn about Smart Contract security</h3>
We already touched on the importance of Smart Contract security when it comes to dApp and Blockchain development. Take some time to read through our <a href="https://wiki.cryptodevhub.io/ethereum-evm/security">Security</a> page and learn more about recent hacks and potential pitfalls.
<h3>8. Join Communities</h3>
Learning never stops and is best nurtured via thoughtful discussions and working with others. Our <a href="https://wiki.cryptodevhub.io/ethereum-evm/communities">Communities</a> page will show you all the Ethereum communities you might want to join.
You should also consider contributing back to your favorite Open Source projects (or start your own). Not only do you provide immediate value, working on Open Source is one of the best ways to solidify your knowledge and grow as an engineer.
<h3>Bonus: Streamline your DX</h3>
While Truffle and Hardhat help you getting up to speed there's more tooling you can leverage to streamline your overall workflow and Developer Experience.
Yos Riady's article "<a href="https://yos.io/2019/11/10/smart-contract-development-best-practices/">Best Practices for Smart Contract Development</a>" is a treasure trove of great advice on how to setup a professional development environment.
In addition to that you should also check out Paul Berg's <a href="https://github.com/PaulRBerg/create-eth-app">create-eth-app</a> or Austin Griffith's <a href="https://github.com/austintgriffith/scaffold-eth">scaffold-eth</a> projects which will help you getting started even faster.
You can find a more thorough list of useful tools on our <a href="https://wiki.cryptodevhub.io/ethereum-evm/tools">Tools</a> page.

Learn Solidity and Smart Contract development to build dApps on Ethereum-Virtual-Machine (EVM) based chains.

Blockchain Development Tutorial

The "All About Solidity" Blog Post Series is a collection of in-depth blog posts on various aspects of Solidity and the Ethereum Virtual Machine (EVM). Reading through it you'll learn everything there is to know about addresses, assembly, comments, contracts, functions, libraries and more.
Protip: Browse through the corresponding <a href="https://github.com/CJ42/All-About-Solidity">GitHub repository</a> to find more writeups which haven't been published yet.

A Blog Post Series to help Smart Contract Developers build better dApps.

All About Solidity

Yos Riady's Blog Post on Smart Contract development best practices is a stellar mini tutorial series which outlines how you can setup a professional development environment to streamline your dApp workflows.
Working through his list you'll learn about static analysis, linters, runbooks, the usage of public testnets as well as best practices for building solid frontends and backends.

Learn Smart Contract development best practices with the help of this mini-tutorial series.

Best Practices for Smart Contract Development

The "Building Secure Smart Contracts" tutorial by Trail of Bits is one of the best resources to learn about Smart Contract development best practices and toolings in a hands-on fashion.
While working through it you'll learn how to setup a secure Smart Contract development workflow, ways to securely integrate tokens into your dApp and which tools you should use to statically analyze your code for potential bugs and undesired side-effects.

This Tutorial by Trail of Bits teaches you everything you need to know about Smart Contract security.

Building Secure Smart Contracts

The "Clean Contracts" blog post by Wesley van Heije is a long-form articles which walks you through everything you need to know to write maintainable, secure and gas optimized Smart Contracts.
Protip: Also make sure to check out the accompanying <a href="https://github.com/wslyvh/clean-contracts">GitHub Repository</a> which has supporting code examples.

Learn how to write maintainable Smart Contracts.

Clean Contracts

In "CryptoZombies" you'll learn Solidity, one of EVMs programming languages by building an NFT game in which you create, train and grow an army of Zombies.
Given its playful nature it's one of the best best introductions to the EVM and Solidity. While definitely interesting you might want to focus on the first two mini-courses and skip the "Beyond Ethereum" one when starting out.

Learn Solidity and dApp development by building a Zombie game.

CryptoZombies

The "Ethereum Blockchain Developer Guide" is a massive collection of tutorials and resources to learn the ins and outs of practical Ethereum development.
While working through the curriculum you'll learn how the Ethereum blockchain works, why transactions are structured the way they are and what the Smart Contract lifecycle is comprised of. Finally you'll apply everything you learned in various labs to test your hard earned knowledge and build up a portfolio of blockchain dApps.

A collection of resources to learn Web3 development.

Ethereum Blockchain Developer Guide

The Ethereum foundation has its own curated list of community tutorials.
Use the filters at the top to find the content you're interested in and if you wrote a tutorial yourself be sure to click the "Submit a Tutorial" button at the top to get added to the list as well.

Ethereum Development Tutorials

This ~5 hours video course teaches you everything you need to know to build and deploy dApps on Polygon.
Working through it you'll learn about the Polygon Ecosystem, the matic.js library, the Token Bridge, Meta Transactions on Polygon, how to integrate Chainlink Oracles, how to run your own Polygon Node and more.

Full Course on Polygon Development - Build Blockchain Apps on Polygon

Learn X in Y minutes has a dedicated site for Solidity development. In it you'll learn how to use the Remix Online IDE, how to work with testnets and how to setup MetaMask. The core focus however is on a huge example Smart Contract written in Solidity, showcasing various language features. While it might be hard for newcomers to work through this gigantic file, Learn X in Y minutes is definitely a good resources for intermediate developers to revisit every now and then.

A mini-tutorial and reference to learn Solidity

Learn X in Y minutes - Solidity

Learn X in Y minutes also has a dedicated site for development with the Vyper programming language. After a brief introduction to Vyper you'll see a huge annotated Smart Contract written in Vyper which walks you through its various language features. While it might be challenging for Vyper devs who are just starting out you'll definitely want to bookmark this page and visit it when you need a quick Vyper refresher.

A mini-tutorial and reference to learn Vyper

Learn X in Y minutes - Vyper

This massive ~16 hours video course teaches you everything you need to know about Blockchain technology, Smart Contracts, Solidity, NFTs, DeFi, Chainlink and full stack dApp development.
The course's code repository can be found <a href="https://github.com/smartcontractkit/full-blockchain-solidity-course-py">on GitHub</a>.

Smart Contract development course for Python programmers.

Solidity, Blockchain and Smart Contract Course – Beginner to Expert Python Tutorial

The "Solidity by Example" website is a treasure trove of great outcome-focused tutorials. Do you want to create your own ERC-20 token or create Bi-directional payment channels? Whenever you get stuck you'll definitely want to check out this resource as it might list a tutorial which helps you solve your problem.

An introduction to Solidity with simple examples.

Solidity by Example

The "Solidity Smart Contract Programming" project is a collection of writeups and code snippets that help you master Smart Contract development with the Solidity programming language.
The 17 part series starts with the basics and teaches you everything you need to know to become a proficient dApp developer for EVM-based Blockchains.

A collection of code snippets and writeups about dApp development.

Solidity Smart Contract Programming

The "Solidity Workshop" project is a collection of guides and resources for Ethereum- and Smart Contract development. It covers topics such as Solidity language concepts, Contract-oriented programming as well as deep dives into advanced Solidity and Ethereum Virtual Machine (EVM) principles concerning inline assembly, memory- and storage layout, the EVM stack and more.
While the repository has been tagged as "legacy" the core concepts still hold true today.

Self-paced workshop to learn the Solidity programming language.

Solidity Workshop

This Blog Post written by Nader Dabit gives an excellent overview and introduction to all the necessary tools for modern dApp development such as React, Hardhat, Ethers and The Graph.
Once you've worked through the tutorial you've learned how to integrate Metamask into your application, how to deploy and test Smart Contracts on Ethereum testnets, how to connect the dApp to a client frontend and how you write and compile contracts written in Solidity.
The code for the whole application can be found on this <a href="https://github.com/dabit3/full-stack-ethereum">GitHub repository</a> and if you're a visual learner you can check out the accompanying 1 hour long <a href="https://www.youtube.com/watch?v=a0osIaAOFSE">YouTube video</a>.

Follow this guide to build your first full stack Ethereum dApp.