Take a look at some sample dapps below and see the possibilities of building on the IC. All samples and further projects can be found in the samples repo. Additional resources can be found in the awesome DFINITY repo (a curated set of open-source projects and examples from our community) or Hackathon projects!
The dapp equivalent of 'Hello, World!' with a separate backend and frontend canister serving a web page.
A sample dapp that shows a dynamic actor (class) instantiation.
A simple dapp that hows the IC management canister as an actor (reference).
This example demonstrates a basic calculator dapp. It uses an orthogonally persistent cell variable to store an arbitrary precision integer that represents the result of the most recent calculation.
This dapp provides a frontend and a backend that shows a simple certified variable (a single 32-bit number), with client-side certificate validation.
A simple dapp that shows a basic (stable) variable demo.
Basic decentralized autonomous organization (DAO)
Decentralized governance is highlight of the IC and is illustrated by the basic DAO sample code. It illustrates how to initialize a set of accounts and corresponding tokens, how account owners can submit proposals for other account owners to vote on, and how a proposal is executed given enough favorable votes.
Basic decentralized exchange (DEX)
To enable DeFi applications on the IC, canisters need to interact with token canisters and the ledger canister. This example dapp illustrates these interactions by showing how to enable an Exchange to take custody of funds, update an internal balance book as users trade, and give custody back to the user as funds are withdrawn.
Encrypted note-taking dapp
Create, access, modify confidential notes from multiple devices using Internet Identity service and end-to-end encryption. The sample code relies upon the web-serving and storage capabilities of the IC, and highlights two key functionalities:
- Client-side, end-to-end encryption.
- Multi-user and multi-device support.
This sample dapp gives a basic query function demo.
This sample dapp shows a basic factorial demo.
Game of Life
A dapp sample that demonstrates Conway’s Game of Life, running in a Motoko canister. Demonstrates upgrades among three versions and state migration using stable variables.
The example demonstrates a counter dapp and an HTTP interface. It is essentially an iteration on the counter canister which adds native HTTP interfaces.
Hosting a static website
This tutorial shows how to quickly set up a static website structure, add content and basic styling, and deploy to the IC.
Hosting a web game
The example shows how to deploy a web game on the IC, sample code can be found at samples repo.
This sample code demonstrates how a dapp can transfer ICP to its most active users.
Internet Identity integration
Minimal counter dapp
This NFT minting dapp showcases how easy it can be to create a user generated NFT and share it. This dapp uses the DIP721 NFT standard.
This is an NFT wallet example dapp that utilizes minted NFTs from the Rust dip721-nft-container. Among some of its essential features, the wallet can register NFTs, transfer out NFTs and check how many NFTs it contains. This dapp includes a frontend UI for interaction.
This example demonstrates different ways of scheduling periodic tasks on the Internet Computer: timers and heartbeats. The example shows the difference between the two, and helps to decide which method suits you the best.
The example dapp shows how to build a simple dapp in Motoko, which will have persistent storage. The dapp is a simple counter, which will increment a counter, retrieve the counter value and reset the counter value by calling backend functions. The functions are exposed through a Candid interface.
This simple dapp is a CRUD-like demo service for storing pieces of related information, such as names and phone numbers.
This sample shows multiple canisters, with publisher-subscriber inter-canister calls.
This example shows how to sort an array, via quick sort, in Motoko.
Sending and receiving cycles
This sample dapp illustrates how to receive and transfer cycles and check a balance.
This sample is a CRUD-like demo service, sans a front end; see also: phone book and superheroes.
This example is a simple CRUD dapp.
Who am I?
This dapp is a simple canister that reports the Principal of its caller.
Explore further samples in Motoko
This is a collection of repo-links to additional code samples written in Motoko. Most are also available in the Motoko playground. The playground provides the simplest environment for trying out pure Motoko samples without having to download and learn to use the SDK, but does not support dapps with frontends.
These samples demonstrate how to build dapps on the IC, with frontends based on React and TypeScript.
Auth client demo is a simple authentication with Internet Identity.
IC-avatar is a full-stack Motoko + React with more advanced authentication, image uploads, and optimistic updates.
Large samples contributed by the community and not necessarily up-to-date:
Certified asset canister and forum post demonstrates a larger application of Internet Computer certified variables.
IC Vault demonstrates end-to-end content encryption.
QR code generator with accompanying Medium article.
Video Guides for Building Dapps
These videos from the community conversations series cover an introduction to building dapps in Rust, and best practices for building dapps in Rust.
Community conversations | overview of building a dapp in Rust.
Community conversations | best practices for canisters in Rust.
Additional useful video series can be found at coding with Kyle.