Technology
Six-second blocks, deterministic Wasm contracts, and a runtime you can upgrade without a hard fork. Build on it from the first commit.
Hybrid consensus
Two cooperating protocols. BABE produces blocks every six seconds. GRANDPA finalizes them with Byzantine fault tolerance.
BABE assigns block authors through a verifiable random function in six-second slots, grouped into four-hour epochs. GRANDPA delivers deterministic finality by voting on chains rather than individual blocks - so a single round can finalize many at once.
The chain stays optimistic and fast: blocks continue producing while finality runs in parallel. Validators tolerate fewer than a third of Byzantine actors. Every safety violation is accountably attributable to a specific validator - and that validator can be slashed by anyone who submits the proof on-chain.
Smart contracts
Write contracts in Rust with ink!, or compile Solidity to Wasm through Solang.
Either path produces deterministic, weight-metered WebAssembly bytecode. Contracts share code by hash, call each other up to five frames deep, and refund unused weight.
Maximum code size is 123 KB. Storage is deposit-based - you reserve TAL when you write, get it back when you delete. No per-operation rent. Cross-contract calls support atomic value transfers - TAL attached to a call is rolled back if the call reverts. Parent calls can also catch a failed child and decide whether to propagate or recover.
Weight pricing is set at 2% of the Substrate reference value - roughly 50Г— lower than the default - so contract execution costs scale accordingly. The same WebAssembly determinism that secures consensus also guarantees that every node executing your contract reaches the same result.
Contract addresses are derived deterministically as Blake2-256(deployer ‖ code_hash ‖ input ‖ salt), so you can predict where a contract lands before deployment. The runtime's CallFilter is currently set to Nothing - contracts cannot dispatch arbitrary calls to other pallets, and the path to relax this runs through audit and a governance referendum.
Native primitives
Assets, NFTs, and identity exist at the runtime level - without deploying any smart contract.
Issue a fungible token in one transaction. Mint NFT collections, set attributes, run atomic swaps. Register an on-chain identity with third-party registrar judgements.
pallet_assets gives you ERC-20-equivalent functionality with native fees, freeze controls, and granular admin roles. pallet_nfts covers collections, attributes, deadlined approvals, off-chain meta-transaction signatures, and atomic swaps. pallet_nft_fractionalization splits a single NFT into fungible shares and reassembles it when all shares return to one holder.
These run on the chain itself, not on top of it. Lower fees, higher throughput, no transfer hooks - and you can compose them with your own ink! contracts when you need custom logic.
Validator network
Nominated Proof of Stake elects validators each era through the Sequential PhragmГ©n algorithm.
Validators bond TAL as collateral and run nodes. Nominators back validators with their own commitments, sharing both the outcomes and the slashing risk.
Election
Sequential PhragmГ©n distributes nominator commitments to maximize the smallest backed stake - a representative active set rather than a winner-take-all leaderboard.
Active set
The runtime supports up to 1,000 active validators. Each era, up to 256 nominators per validator share in that validator's outcome. Withdrawing bonded TAL initiates a 28-day unbonding cycle, after which the funds become transferable.
Slashing
Validator misbehavior - equivocation or sustained unresponsiveness - triggers slashing of bonded TAL, deferred for 27 eras during which the Council can cancel non-malicious incidents.
Fee split
Of every transaction fee, 80% flows to the on-chain Treasury and 20% to the block author. The same split applies to tips.
Forkless evolution
Upgrade the runtime through on-chain governance. Every change ships to every node at a scheduled block - transparently, by referendum.
When a referendum passes, the new WebAssembly runtime takes effect at the scheduled block. Every node downloads and runs it automatically - protocol changes ship without a coordinated hard fork.
Democracy, an elected Council, a Technical Committee, and a community-funded Treasury share the work of governance. Voters lock TAL for chosen periods - longer locks multiply their conviction up to 6Г—. The Technical Committee can fast-track urgent proposals; the Council can cancel dangerous ones; the Treasury funds development with 80% of all transaction fees.
For a developer, this means the protocol you build on today can evolve transparently - and you can participate in the decisions that shape it.
See governanceWhat you're building on
Three qualities every developer can rely on, from prototype to production.
Taler is built with Substrate - a toolkit for application-specific blockchains that compile to WebAssembly. Each pallet handles one domain of the runtime: balances, consensus, staking, contracts, governance, assets, identity. The set evolves through on-chain referenda.
Open architecture
Modular pallets define every runtime domain. New pallets can be added through runtime upgrades, without touching the existing code
Native assets
Fungible tokens, NFTs, and identity records live at the runtime level - no smart contract deployment required
On-chain governance
Democracy, an elected Council, a Technical Committee, and a community-funded Treasury coordinate protocol decisions
Build on Taler
Rust or Solidity. Native assets. Forkless upgrades. Start a project on Taler in under an hour.
Install dependencies, spin up a dev node, deploy your first contract - the guide walks through every step, with code samples and the full pallet reference.
Deploy your first contract