Daml is an open-source smart contract language designed to build composable applications on an abstract ledger model.

Daml is a high level language that focuses on data privacy and authorization of distributed applications. These concepts are represented first class in the language.

By abstracting data privacy and authorization, Daml takes the burden off the programmer to think about concrete cryptographic primitives and lets her focus on workflow logic.

Daml is a statically typed functional language.

The full documentation of Daml can be found here .

If you are interested you can find the detailed glossary here and a free online course here.

Every Daml file starts with a module header like this:

module Foo where

Functions are first class members of Daml, in particular, functions can be arguments to functions

apply : (Text -> Text) -> Text -> Text
apply h x = h x 

apply salute "John" -- "Hello John"

Contract templates describe data that will be stored on the ledger. Templates determine who can read and write data; and by whom and how this data can be altered. A contract template is defined with the template keyword:

template MyData
  with
    i : Int
    party1 : Party
    party2 : Party
    dataKey : (Party, Text)
  where
    signatory party1
    observer  party2
    key dataKey : (Party, Text)
    maintainer key._1

    choice MyChoice : ()
    ...

with and where are keywords to structure the template.

Contract keys are unique and stable references to a contract that won’t change even if the contract id of that contract changes due to an update.

Contract keys are optional.

Contract keys have an associated set of key maintainer parties. These parties guarantee the uniquess of their maintained keys.

Contract keys are specified on a contract template with the key and maintainer keywords. If you specify a key you also have to specify its maintainers.

The choices of a contract template specify the rules on how and by whom contract data can be changed.

(nonconsuming) choice NameOfChoice : ()
-- optional nonconsuming annotation, name and choice return type
  with
    party1 : Party          -- choice arguments
    party2 : Party
    i : Int
  controller party1, party2 -- parties that can execute this choice
    do                      -- the update that will be executed
      assert (i == 42)
      create ...
      exercise ...
      return ()

Choices can be consuming or nonconsuming.

Updates specify the transactions that will be committed to the ledger. Updates are described within a do block:

do
  cid <- create NewContract with field1 = 1
                                 , field2 = "hello world"
  let answer = 42
  exercise cid SomeChoice with choiceArgument = "123"
  return answer

Daml script is a scripting language to run Daml commands against a ledger. For example:

module Test where

import Daml.Script

test : Script ()
test = do 
  alice <- allocateParty "Alice" 
  bob <- allocateParty "Bob"
  c <- submit alice $ createCmd NewContract with ...
  submit bob $ exerciseCmd c Accept with ...

Scripts are compiled like usual Daml code to a dar package with the daml build command.

Daml ledgers expose a unified API for interaction.

The following describes how to interact with a ledger using the TypeScript libraries @daml/ledger, @daml/react in a frontend build with React .

Import the libraries via:

import Ledger from @daml/ledger
import {useParty, ...} from @daml/react

React entry point:

import DamlLeddger from @daml/react

const App: React.FC = () => {
     <DamlLedger
      token: <your authentication token>
      httpBaseUrl?: <optional http base url>
      wsBaseUrl?: <optional websocket base url>
      party: <the logged in party>
    >
      <MainScreen />
    </DamlLedger>
};

• Official documentation
• The Daml code repository
• A Daml project template
• Read about how people are using Daml on the Daml Blog