Awesome Daml

Curated resources for learning Daml the smart contract language behind the Canton Network and for finding your way around the Canton developer ecosystem.

Daml is a strongly-typed, Haskell-derived language for multi-party workflows. Instead of a global shared state, every contract carries an explicit set of signatories and observers, so who is allowed to see and do what is part of the type-checked model rather than an afterthought. That model is what Canton executes and synchronizes across independently-operated participant nodes.

Which docs site should I start with?

The official documentation site is docs.canton.network. It covers Daml 3.x, Canton 3.5, and the current tooling.

This document also links to older documentation sites (docs.daml.com and docs.digitalasset.com), whenever they still provide somewhat relevant and useful learning material.

Contents

• Start Here
  • Coming from Ethereum?
• Learning the Language
• Language Reference
• The Ledger Model
• Tooling
• SDKs and Bindings
• Libraries
• Example Applications
• Running Code Locally
• Upgrades and Production
• The Canton Ecosystem
• Data and Explorers
• Agentic Development
• Papers
• Community articles
• Community Forums

Start Here

• Choose Your Path: routes you to the right module depending on whether you're writing contracts, an app, or running a node.
• Canton Network QuickStart: clone a working full-stack app and get it running before learning any theory.
• Module 1: Understanding Canton: the conceptual groundwork the rest of the docs assume you have.

Coming from Ethereum?

• Canton for Blockchain Developers: written for people arriving from EVM/Solidity. Focus on the privacy and authorization sections.
• Concept Translation Tables: mapping the terminology and the concepts between the two.
• Canton + Daml Auditor Bootcamp: aimed at auditors arriving from EVM or Move, organized around twenty recurring Daml vulnerability patterns with code for each. Also the fastest way for a non-auditor to learn what bad Daml looks like.

Learning the Language

• An Introduction to Daml: the long-standing tutorial course, building an asset-trading app chapter by chapter. Still a fine introduction to the language, even though it targets 2.x tooling.
• Module 3: Daml Smart Contracts: the 3.x treatment, split across templates, choices, authorization, interfaces, and contract keys.
• Composition and Design Patterns: Concepts like propose/accept, delegation, role contracts that separate working Daml from elegant Daml.
• Daml Patterns (2.x): the original pattern catalogue, with fuller worked examples.
• Testing Daml Contracts: Daml Script as a test harness, including multi-party scenarios.
• Working with Time: ledger time vs. record time, and why naive time handling breaks under contention.
• Training and Certification: Digital Asset's structured path, including the Daml Fundamentals exam.
• The structure and flow of Daml smart contracts: two-part article separating the static shape of a contract from its runtime behavior. (part 2)

Language Reference

• Daml Cheat Sheet: one page, syntax and stdlib. (source)
• Daml Language Reference: the syntax and semantics, authoritative.
• Daml Standard Library: DA.List, DA.Map, DA.Text, DA.Time and the rest, module by module.
• Prelude: what's in scope without importing anything.
• Daml.Script: the API you write tests and ledger-initialization scripts against.
• Daml-LF Reference: the intermediate representation Daml compiles to. Relevant once you care about package identity and upgrade compatibility.
• Error Codes: searchable list, useful when the ledger rejects a submission and you want the actual reason.

The Ledger Model

The formal model is worth reading properly, especially the authorization and privacy parts.

• The Ledger Model: transactions as trees, with authorization rules over the nodes.
• Privacy Model Explained: subtransaction privacy i.e. who learns which parts of a transaction, and why.
• Privacy Model for App Developers: privacy model's design consequences for your app.
• How Transactions Work: submissions, commits and confirmations.
• Two-Layer Consensus: how Canton separates ordering from validation.
• Trust Model Overview: what each participant has to trust, and what it doesn't.
• Composing Multi-Party Workflows: why Daml workflows compose across organizations that don't trust each other.
• Explicit Contract Disclosure: handing a contract to a non-stakeholder without making them an observer.

Tooling

Check the official Canton developer tooling site first. Developer tools, SDKs, APIs, and AI Infrastructure for Building on Canton Network. To get your projects included, their repo is open to PRs.

• dpm: the CLI: scaffolding, builds, tests, codegen, SDK version management. Replaces the daml assistant from SDK 3.5 on. (repo)
• Daml SDK: compiler, Daml Script runner, and sandbox, installed via dpm.
• Daml Studio: the VS Code extension. Type checking, inline script results, go-to-definition.
• IDE Setup: getting the editor tooling actually working, which is not always automatic.
• Development Tools Overview: what each tool in the box is for.
• PQS (Participant Query Store): streams ledger state into PostgreSQL so you can query contracts with SQL. (repo, SQL reference)
• Canton Console: Scala REPL against a node, for topology and admin work.
• Debugging Tools and Debugging with lnav: for when the logs are the only evidence you have.
• Troubleshooting Cheat Sheet: symptom-to-cause table. Pairs with the common issues FAQ.
• Seaport: hosted environment for building and deploying Daml without a local toolchain.
• daml-lint: OpenZeppelin's static analyser, doing for Daml roughly what Slither does for Solidity: unguarded division, unbounded decimals, missing ensure clauses. Explicitly experimental.
• daml.nvim: Neovim support with LSP, inline script results, and Tree-sitter highlighting. The only serious alternative to the VS Code extension.
• CantonTrace: local debugging UI: ACS inspector, transaction tree with per-party privacy analysis, and step-through of the Daml engine. Fills a genuine gap in the official toolchain.
• daml-fuzz-canton: property-based fuzzer. You declare the invariants; it generates multi-party transaction sequences trying to break them, covering authorization, privacy, and value conservation. Proof of concept, and the invariant categories are a useful checklist even if you don't run it.
• Mewt: mutation testing with Daml support, including mutants that swap controllers and signatories. Reach for it when Daml's choice-level coverage says 100% and you want to know what that is worth. (announcement)
• daml-security-framework: proof-of-concept static scanner and a vulnerability taxonomy with worked examples, such as non-consuming choices with side effects. Early; the taxonomy currently carries more value than the scanner.
• Decentralization Manager: runs a decentralized party across multiple participants: threshold governance, coordinated onboarding, DAR deployment with multi-party signing, and membership votes. For when a single operator holding the party's keys is not acceptable.

SDKs and Bindings

• JSON Ledger API: plain HTTP against the ledger. (tutorial)
• gRPC Ledger API: the full API, including event streaming.
• Wallet SDK: TypeScript, for party management, transfers, and transaction signing.
• Wallet Gateway: dApp-side SDK and OpenRPC spec for talking to Canton wallets from a frontend.
• PartyLayer: CIP-0103 wallet abstraction. One integration covers Console, Loop, Cantor8, Nightly and the rest, with React hooks and a signed registry so wallet identities can't be spoofed. MIT. (docs)
• dazl: Python Ledger API client. (PyPI)
• go-daml: Go client with a type-safe code generator that reads .dar files.
• c7_ledger: actively maintained drop-in replacements for @daml/ledger and @daml/react.
• Contracts and Transactions in Java: working with generated Java codegen output.

Libraries

• Daml Finance: instruments, holdings, settlement, and lifecycling. Don't model a financial asset from scratch before reading this. (docs)
• daml-ctl: small control-flow helpers ported from Haskell.
• Canton Token Template: Starting point for a CIP-56 compliant token registry, by OpenZeppelin.
• canton-stablecoin: extends the token template above with a CDP vault system: overcollateralization, minting, liquidation, stability fees, plus tests for the security invariants. Explicitly experimental.
• daml-tokenization-toolkit: tokenization and settlement built on Daml Finance, by ASX Operations.
• account-hierarchy: custody and account-hierarchy modelling for solving the nested-ownership problem.
• daml-nft: small NFT library.
• Catalyx Package Manager: community marketplace for reusable Daml packages.

Example Applications

• cn-quickstart: the reference full-stack app: Daml models, backend, frontend, and a LocalNet to run it against.
• daml-finance-app: larger demo built on Daml Finance.
• ex-java-bindings: the same example client written three ways, for comparing the abstraction levels.
• ex-java-bindings-with-opentelemetry: adds tracing to the above client.
• splice: the Global Synchronizer's own applications: Canton Coin, Scan, validator, and SV apps. For reviewing what the production-quality Daml looks like.
• example-insurance-claim: an insurance claim as a multi-party workflow example.
• canton-erc20: ERC-20 bridge between Ethereum and CIP-56 tokens, by ChainSafe. (Go middleware)
• data-streams-canton: Chainlink Data Streams on Canton. The reference for getting external price data onto the ledger.
• hemera: Daml-to-Ethereum integration over the Java bindings. Unmaintained since 2023, but the same pattern of offchain integrations still works.
• daml-on-sawtooth: Daml's runtime on Hyperledger Sawtooth. Unmaintained, but works as an example of Daml being a ledger-agnostic language.

Running Code Locally

• LocalNet Development: a full network (validators, synchronizer, wallets, PQS, Keycloak) in Docker Compose.
• Development Environment Setup: the minimal setup, before you need Docker.
• Deployment Progression: sandbox to LocalNet to DevNet to production.
• Deploy Quickstart to DevNet: first deployment onto a shared network.
• Testing Strategies: where Daml Script stops being enough.
• CI/CD Integration: building and testing DARs in a pipeline.

Upgrades and Production

Daml packages are immutable and content-addressed, which complicates the upgrades.

• Smart Contract Upgrades Overview: start here, then writing your first upgrade.
• Upgrade Compatibility and Limitations: what you're allowed to change, and what you'll regret.
• Smart Contract Upgrade (SCU) deep dive: about the upgrade mechanism itself.
• Package Selection and Package Naming: naming is extra important to get right early.
• Security Best Practices: Daml-specific security practices.
• Performance Best Practices and Performance Optimization.
• Error Handling: retryable vs real failures.
• Application Architecture Design: how to design your application stack (frontend, Daml models, backend).
• Observability and Open Tracing.

The Canton Ecosystem

• Canton Network: the network itself, and its problem statement.
• Canton Network in 5 Minutes: tldr.
• Glossary
• Canton Improvement Proposals: where protocol and standard proposals are developed. For instance, CIP-56 defines the token standard.
• Token Standard: about the CIP-56.
• Canton Foundation: governance, plus their grants program.
• Canton Development Fund: funding process in the open.
• Canton Ecosystem: directory of apps and wallets on the network.
• Canton: the protocol implementation, in Scala.
• Daml: the compiler, standard library, and language runtime. Apache-2.0.
• Canton Hub: community resource hub covering education, dev, and validator material.
• Onboarding & Dev Fund Guide: community walkthrough of the devnet-to-testnet-to-mainnet progression, and how Dev Fund proposals actually get approved.

Data and Explorers

• Scan API: read-only network data: mining rounds, Canton Coin (CC) supply, DSO state.
• Validator API: per-node REST API for wallet ops, traffic, and party onboarding.
• Noves Canton Data API: hosted API over publicly observable network data.
• CCView: explorer with a public indexing API. (API docs)
• Lighthouse: alternative community explorer.
• CC Space: explorer with analytics, alerting, and validator monitoring.

Agentic Development

• Canton Foundation MCP: MCP server serving current Canton docs to coding assistants.
• Claude Code Daml Skill: packaged Daml knowledge for Claude Code.
• CCPedia: AI-queryable index over CIPs, forum threads, docs, and Dev Fund proposals.

Whitepapers etc

• Daml: A Smart Contract Language for Securely Automating Real-World Multi-Party Business Workflows: Bernauer et al., 2023. The language paper: the authorization model, the privacy model, and the reasoning behind the template/choice design. The single best technical account of why Daml looks the way it does.
• Canton: A Daml based ledger interoperability protocol: the original 2020 technical paper, and considerably more precise than the marketing pages that superseded it.
• Canton Network whitepapers: the full set, including the Canton Network paper and the Canton Coin papers.
• Polyglot Canton: the case for opening Canton to languages beyond Daml, running Solidity and others over WebAssembly.
• Daml Ledger Model (2.x): the formal treatment of transactions, authorization, and privacy. Dense, and worth it.

Academic Research

• Access Control Verification in Smart Contracts Using Colored Petri Nets: Al-Azzoni & Iqbal, Computers, 2024. Parses Daml templates into Petri nets and model-checks the access control. Open access.
• Smart contract life-cycle management: Mustafa, McGibney & Rea, Frontiers in Blockchain, 2024. A verification framework for Daml contracts, including a type-safety checker for access-control and IDOR-style flaws. Open access.
• Visual Smart Contracts for DAML: Heckel et al., ICGT 2022. Graph-transformation semantics for Daml, aimed at making contract behaviour visually inspectable.
• Dynamic Role-Based Access Control Scenarios for Smart Contracts: Al-Azzoni, Heckel & Erum, Journal of Object Technology, 2025. Generating Daml access-control tests via graph rewriting. Open access.
• Modelling Multi-Party Role-Based Access Control Policies for iContractML Smart Contracts: Al-Azzoni & Heckel, ASEW 2023. Models RBAC once, then maps it to both Solidity and Daml.
• Decentralized Oracle Networks (DONs) Provision for DAML Smart Contracts: Mustafa et al., 2023. Integrating Oracles into Daml.

Community articles

• My thoughts after 6 months working with DAML: a practitioner's retrospective.
• DAML: A Haskell-Based Language for Blockchain: on what Daml inherits from Haskell and what it deliberately drops.
• Learning Daml: Advantages and Challenges: thoughts on security-audit perspective.
• Deep Dive on Permissioned Blockchains: The Canton Network: Flashbots Collective research thread.
• Exploring Canton Network: privacy-first distributed ledgers: walkthrough of the privacy architecture.
• DAML Development Guide
• Daml Masterclass: long-running series on full-stack Daml, including driving the ledger from Rust.
• Canton Network Learning Hub: four levels of question-and-answer material, from what Canton is up to transaction mechanics and CIP-56. The developer track is levels 2 and 3.

Community Forums

• Canton Network Forum: formerly the Daml forum, and still a place where the language questions get answered by people who wrote the compiler.
• Official Discord.
• Official Telegram
• Stack Overflow daml tag: not active, but the old language-specific answers are often still correct.
• GitHub daml topic: for finding projects not catalogued anywhere else.
• Digital Asset on YouTube: talks and recorded sessions.
• Canton Network blog

Contributing

Pull requests welcome. One link per entry, a description that says what the thing is and when you'd reach for it, and no marketing copy. Dead links get removed without ceremony.

License

CC0-1.0.