-## Building the next generation of software and services
+In the conceptual diagram above, decentralization increases going from centralized servers to Ethereum, but that happens at the expense of scalability.
+ICP is located in the middle of this spectrum.
-The Internet Computer protocol reduces platform-based risks and paves the way for innovation by re-imagining how software is built, deployed, and accessed.
+## Subnets
-For example, with the Internet Computer, developers can focus on writing code using canisters without environment-related distractions such as:
+One of the keys for high scalability is sharding.
+ICP shards smart contracts over multiple instances of the blockchain.
+Each instance is called a **subnet** and has its own set of decentralized nodes running the consensus algorithm among themselves, building their own chain of blocks, and executing smart contracts.
+Each subnet runs in parallel with other subnets.
+A smart contract on one subnet can communicate with another smart contract on a different subnet through sending messages.
-- Physical or virtual network configuration requirements.
+A user interacts with a smart contract by sending a digitally signed message.
+The following diagram shows the flow of the message on ICP:
-- Load balancing services.
+1. The message goes to one of the boundary nodes (RPC nodes).
+1. The boundary node routes the message to the subnet that hosts the target smart contract.
+1. The consensus algorithm of that subnet adds the message to a new block in the subnet's blockchain.
+1. The message is added to the input queue of the target smart contract.
+1. The smart contract executes the message.
-- Firewalls, network topology, or port management.
+Note that steps 3-5 are asynchronous and decoupled from each other, which may be unusual for developers who are used to Ethereum-style atomic transactions that are executed when they are added to a block.
+The motivation for this design is scalability.
-- Database configuration and maintenance.
+
-- Storage volumes and devices.
+Subnets can have different sizes, i.e. replication factors, which determines the cost of running smart contracts on that subnet.
+It also impacts the time to finality and security.
-By enabling developers to focus on building applications and delivering value, the Internet Computer helps simplify the development process, reduce time to market, and foster innovation.
-For end-users, the Internet Computer provides a secure environment for accessing dapps with fewer risks. Because of the inherent security of the blockchain, programs running on the Internet Computer cannot be hijacked by malicious code, which also reduces the total cost of ownership for both application end-users or organizations.
+## Threshold signatures
-In addition, because dapps can be "autonomous" and public, developers can write services that communicate with each other and share functions in ways that increase productivity and efficiency while leaving room to innovate and improve projects with confidence.
+Each ICP subnet has a fixed public key.
+The corresponding private key is not stored on a single node, nor is it ever available on any node.
+Instead, it is split into multiple secret shares and distributed over all nodes using threshold cryptography.
+Nodes can collectively sign messages to users and other subnets using these secret shares.
+This makes validation of the state and results trivial for users since all they need to do is verify the digital signature against the fixed public key without downloading and validating blocks in the blockchain.
-The Internet Computer also enables developers to use [cryptographically-secure identities](/how-it-works/web-authentication-identity/) to enforce access controls, reducing the need to rely on usernames and passwords or external identity management plug-ins.
+This feature has profound implications and use cases:
-## Learn more
+- There is no need to keep the blocks in the blockchain available forever, which would be a scalability bottleneck.
+ In fact, ICP actively garbage collects old blocks to keep storage usage bounded.
+- Smart contracts [can have their own secret keys](https://medium.com/dfinity/how-icps-bitcoin-integration-secures-private-keys-c2af14597846) and can sign transactions for other blockchains such as Bitcoin and Ethereum.
+ This enables trustless interaction with those blockchains.
-- [Architecture](/how-it-works/architecture-of-the-internet-computer/).
+
-- [Protocol overview](/how-it-works/core-ic-protocol-overview/).
+:::info
+This feature is called Chain-Key Cryptography on ICP.
+:::
-- [Canisters](/how-it-works/canister-lifecycle/).
-- [Internet Identity](/how-it-works/web-authentication-identity/).
+## Smart Contracts
-- [Chain-key cryptography](/how-it-works/chain-key-technology/).
+ICP uses [WebAssembly](https://internetcomputer.org/capabilities/webassembly) as the virtual machine for executing smart contracts.
+This means developers can write smart contracts in popular programming languages such as JavaScript, TypeScript, Rust, Python, and Motoko, which is specifically designed for ICP.
-- [Chain-key tokens](/how-it-works/chain-key-tokens/).
+Furthermore, a single smart contract on ICP is powerful enough to host an entire Ethereum Virtual Machine (EVM).
+This allows the deployment of EVM smart contracts written in Solidity.
-- [The Network Nervous System](https://internetcomputer.org/nns/).
+A unique feature of ICP is that smart contracts can handle HTTP requests and serve web assets such as HTML, JS, CSS.
+In other words, it is possible to write a Web3 application with both backend and frontend hosted fully on-chain.
+Smart contracts can also make requests to other Web2 services outside ICP.
-- [Service Nervous Systems](https://internetcomputer.org/sns/).
+Ethereum developers may be used to the notion that smart contracts run sequentially within an atomic transaction.
+ICP embraces scalability and runs smart contracts in parallel.
+In that regard, smart contracts are similar to processes or microservices from traditional programming.
+Smart contracts can be fully autonomous and can schedule execution using timers without relying on users sending messages.
-## Get started developing on ICP
+In terms of storage, a smart contract can store arbitrary data in its WebAssembly memory.
+Additionally, a smart contract can use a larger **stable memory**.
+The difference between the two memories is important for upgradable smart contracts: the WebAssembly memory is cleared on an upgrade whereas the stable memory is preserved (hence the name “stable”).
+For immutable smart contracts, there is no observable difference between the two memories except for the size and functions to access it.
-- Get started developing on ICP by embarking on your [developer journey](/docs/current/tutorials/developer-journey).
+:::info
+In the context of ICP, smart contracts are referred to as canisters.
+:::
-- [Designing a dapp](/docs/current/developer-docs/backend/design-dapps).
+## Accounts and Keys
-- [Building backend canisters with Motoko](/docs/current/developer-docs/backend/motoko/).
+ICP derives the address of a user account from the user’s public key by hashing it.
-- [Building backend canisters with Rust](/docs/current/developer-docs/backend/rust/).
-## Connect with the ICP community
+
-- [Developer Discord community](https://discord.com/invite/cA7y6ezyE2), which is a large chatroom for ICP developers to ask questions, get help, or chat with other developers asynchronously via text chat.
+The textual encoding of an address includes a checksum that looks something like this:
-- [Developer journey forum discussion](https://forum.dfinity.org/t/developer-journey-feedback-and-discussion/23893).
+```
+mh4eq-xsi7l-lgz7s-gmxoh-stiey-277n4-lev4o-q6hah-22sk6-ahlhm-qae
+```
-- [Developer tooling working group](https://www.google.com/calendar/event?eid=MHY0cjBubmlnYXY1cTkzZzVzcmozb3ZjZm5fMjAyMzEwMDVUMTcwMDAwWiBjX2Nnb2VxOTE3cnBlYXA3dnNlM2lzMWhsMzEwQGc&ctz=Europe/Zurich).
+ICP supports multiple types of keys (ECDSA, Ed25519, BLS).
+Developer tools usually generate and accept keys in PEM format.
-- [Motoko Bootcamp - The DAO Adventure](https://github.com/motoko-bootcamp/dao-adventure) - Discover the Motoko language in this 7 day adventure and learn to build a DAO on the Internet Computer.
+Since smart contracts can have private keys, they can provide user accounts as a service.
+**Internet Identity** is an example of a smart contract that allows Web2 users to have blockchain accounts with the private keys stored securely on the blockchain itself.
-- [Motoko Bootcamp - Discord community](https://discord.gg/YbksCUxdzk) - A community for and by Motoko developers to ask for advice, showcase projects and participate in collaborative events.
+You can also use hardware and browser-extension wallets.
-- [Motoko developer working group](https://www.google.com/calendar/event?eid=ZWVnb2luaHU0ZjduMTNpZHI3MWJkcWVwNWdfMjAyMzEwMTJUMTUwMDAwWiBjX2Nnb2VxOTE3cnBlYXA3dnNlM2lzMWhsMzEwQGc&ctz=Europe/Zurich).
+:::info
+In the context of ICP, addresses are referred to as principals.
+:::
-- [Upcoming events and conferences](https://dfinity.org/events-and-news/).
+## Tokens
-- [Upcoming hackathons](https://dfinity.org/hackathons/).
+Accounts on ICP do not have built-in balances, which is a large design difference when compared to other chains like Ethereum.
+All tokens are implemented by smart contracts.
+ICP has an equivalent of the ERC-20 standard, called [ICRC-2](https://github.com/dfinity/ICRC-1/blob/main/standards/ICRC-2/README.md).
+If a smart contract implements ICRC-2, then it implements a fungible token and has a ledger for it.
-- [Weekly developer office hours](https://discord.gg/4a7SZzRk?event=1164114241893187655) to ask questions, get clarification, and chat with other developers live via voice chat. This is hosted on our [developer Discord](https://discord.com/invite/cA7y6ezyE2) group.
+## Messages
+The programming model of ICP is similar to the [Actor model](https://en.wikipedia.org/wiki/Actor_model), where calls are made by sending messages instead of transactions.
+The difference between a transaction and a message becomes apparent only when the smart contract calls other smart contracts.
+A transaction is atomic in the sense that it rolls back all state changes if any of the calls fail.
+A message does not have such atomicity guarantees across calls.
+Programming on ICP is more asynchronous compared to Ethereum.
+If the smart contract does not make any calls, then the message behaves exactly like a transaction.
+
+## Cycles
+
+On other blockchains such as Ethereum, users pay a variable fee for sending and executing transactions depending on the current gas price.
+In order to simplify the experience of users browsing Web3 applications, ICP employs a “reverse gas model”, where canisters pay for consumed resources by burning **cycles**.
+This is similar to gas in Ethereum, but has a fixed price correlating to a group of fiat currencies.
+
+## Governance
+
+ICP is governed by a decentralized autonomous organization (DAO) community called the Network Nervous System (NNS).
+It is implemented as a set of smart contracts running on ICP itself.
+Community members can participate in governance by staking ICP tokens and voting on proposals.
+All operational changes to ICP, such as upgrading nodes, go through voting.
+NNS automatically executes proposals that have passed voting which ensures that nodes run the same version of the protocol and thus avoids hard forks.
+
+:::info
+Governance and node ownership are decoupled.
+It is possible to participate in governance without having a node and vice versa.
+:::
+
+
+## Nodes
+
+Becoming a node provider on ICP requires voting from the DAO community.
+There are two reasons for this:
+
+1. It ensures that the hardware meets the high standards of ICP: 64 CPU cores, 512GiB of RAM, 30TB of NVMe SSD.
+ Such nodes can sustain high throughput and enable powerful Web3 applications.
+1. It ensures that the identity of the node provider is known to the community.
+ The node provider has signed a declaration of good intent and may be liable if the node misbehaves.
+ This makes Sybil attacks harder to pull off and allows for the ability to reduce the number of nodes while keeping the Nakamoto coefficient high.
+ Nodes are assigned to subnets such that they maximize decentralization, in terms of operators, geography and jurisdiction.
+ This is called **deterministic decentralization**.
+
+Currently, subnets contain between 13 and 40 nodes, and most of them are geographically distributed. However, there can also be localized subnets to support applications that need to comply with local regulations.
+
+## Quick comparison with Ethereum
+
+| + | Ethereum | +ICP | +
|---|---|---|
| virtual machine | +EVM | +WebAssembly | +
| on-chain Web3 | +- | +yes | +
| bridgeless Bitcoin | +- | +yes | +
| smart contracts can sign messages | +- | +yes | +
| HTTP calls to Web2 from smart contracts | +- | +yes | +
| languages | +Solidity, Vyper, Yul | +JS, Python, Rust, Solidity, Motoko, and more | +
| programming model | +atomic transactions | +async message passing | +
| gas model | +user pays | +smart contract pays | +
| gas price | +variable | +fixed | +
| compute | +few million instructions per block (based on the 30 million gas limit) | +2 billion instructions per block (per subnet) | +
| finality | +~15min | +~1.4s | +
| average tx/msg fee | +~$1 | +~$0.000001 | +
| stack size | +32KB (1024 of 256-bit values) | +5MB | +
| code size | +24KB (more with code sharing) | +10MB | +
| memory size | +few KB | +404GB (4GB Wasm memory + 400GB of stable memory) | +
| storage cost | +$18M per GB (based on 640K gas per KB) | +$5 per GB per year | +
| number of nodes | +~7K | +~500 in total, 13-40 per subnet | +