Skip to main content
CodeSpeedTest
Languages
Start TypingJump into a test — pick any languageAdaptive TrainingUnlock chars as you master themPractice DrillsFocused sessions targeting weak spotsDaily ChallengesNew coding challenges every dayRace ModeCompete against others in real timeAI OpponentRace against an AI at your WPM levelTournamentsLive coding speed tournamentsArcade GamesZType, Overkill Survival, Glyphica & moreGamificationXP, coins, badges & quests
LeaderboardGlobal rankings for every languageCertificatesEarn verifiable Bronze / Silver / Gold certsActivityDaily streaks & historical analyticsProfileYour stats, badges & achievements
Browse Languages500+ languages with real code examplesBlogTips, guides & deep divesFree ToolsWPM calculator, typing speed report & moreFAQCommon questions answeredGetting StartedNew to CodeSpeedTest?AboutOur story & missionSupportGet help — Pro users get priorityContactGet in touch with the team
Pricing
  1. Home
  2. /
  3. Learn
  4. /
  5. Clarity

Learn Clarity - 10 Code Examples & CST Typing Practice Test

Clarity is a decidable smart contract language used on the Stacks blockchain. It enables predictable and secure smart contracts without gas estimation or unpredictable behavior.

View all 10 Clarity code examples →
Clarity Simple Counter ContractClarity Token Balance StoreClarity Ownership ModuleClarity Simple Voting SystemClarity Boolean ToggleClarity Fixed Supply TokenClarity Timelock ContractClarity Allowlist ExampleClarity Simple Message StorageClarity Key-Value Store

Learn CLARITY with Real Code Examples

Updated Nov 25, 2025

Explain

Clarity is a Lisp-like language that is interpreted, not compiled to bytecode, ensuring contracts behave deterministically.

It is decidable, meaning all outcomes of contract execution can be known before running.

Contracts can interact with the Bitcoin blockchain via Stacks.

It prevents runtime errors common in other languages by enforcing strict typing and bounds checking.

Used in DeFi, NFTs, and decentralized applications on Stacks.

Core Features

define-public -> exposes functions externally

define-constant -> immutable constants

map, list, tuple types for structured data

Contract-to-contract calls

Error handling via (ok ...) and (err ...)

Basic Concepts Overview

define-public functions for external calls

define-private for internal contract logic

define-constant for immutable values

use maps, lists, tuples for structured storage

ok/err pattern for safe return values

Project Structure

contracts/ - Clarity source files

tests/ - unit and integration tests

scripts/ - deployment scripts

package.json - project configuration

README.md - documentation and usage notes

Building Workflow

Write Clarity contracts using define-public and define-private

Use Stacks CLI to deploy to testnet/mainnet

Interact via Hiro Wallet or Stacks.js

Test contracts with mock Bitcoin integration

Monitor execution deterministically

Difficulty Use Cases

Beginner: simple token contract

Intermediate: NFT minting contract

Advanced: DeFi smart contract with governance

Expert: Bitcoin-integrated financial protocol

Auditor: verify determinism and security

Comparisons

Clarity vs Solidity: Clarity is decidable and predictable, Solidity runs on EVM.

Clarity vs Vyper: Both are safer than Solidity, but Clarity is interpreted and deterministic.

Clarity vs Ink!: Clarity targets Stacks/Bitcoin, Ink! targets Substrate/Wasm.

Clarity vs Ocean SDK: Clarity is smart contract language; Ocean SDK is a data marketplace SDK.

Clarity vs Move: Move is resource-oriented for Diem/Aptos; Clarity is functional and decidable.

Versioning Timeline

2018 - Initial Clarity language release

2019 - Clarity 1.0 formalized

2020 - Extended public/private function support

2021 - Bitcoin integration enhancements

2022-2025 - Continuous updates and ecosystem growth

Glossary

Stacks: blockchain for Bitcoin integration

STX: native Stacks token

Decidability: predictable execution

DDO: not used; Ocean SDK concept

Public/private function: access control in Clarity

Installation Setup

Install Clarity CLI via npm or Docker

Set up Stacks node or use testnet

Install Hiro Wallet for contract deployment

Verify Clarity compiler via sample scripts

Test execution using local Clarity environment

Environment Setup

Install Node.js or Docker for Clarity CLI

Set up Stacks node/testnet

Install Hiro Wallet

Verify Clarity CLI installation

Test deploy sample contract

Config Files

Clarity CLI config

Stacks node settings

Wallet configuration

Deployment scripts

Environment variables

Cli Commands

clarity-cli check

clarity-cli deploy

clarity-cli test

clarity-cli call

clarity-cli interpret

Internationalization

Docs available in English

Community translations ongoing

Global developer reach via Stacks ecosystem

Unicode-safe strings

Bitcoin integration supports global settlement

Accessibility

Accessible with basic Lisp syntax knowledge

Clear error messages due to determinism

Strong documentation from Hiro

CLI tooling available

Integration with testnet simplifies learning

Ui Styling

Frontend via Stacks.js

Wallet integration via Hiro

Metadata-driven UI forms

Dashboard visualization optional

Not directly in Clarity code

State Management

Maps and tuples for storage

Immutable constants

Public/private function state updates

Deterministic event outputs

Cross-contract state access

Data Management

On-chain storage via Clarity types

Immutable constants

Structured storage via tuples/maps

Error handling ensures predictable data state

Interactions recorded deterministically on-chain

Architecture

Interpreted smart contracts executed on Stacks nodes

Contracts interact with Stacks ledger and Bitcoin

Decidability ensures predictable execution

Data storage on-chain with maps and tuples

Events and state changes tracked deterministically

Rendering Model

Clarity source -> Interpreted execution on Stacks

Public/private functions define external/internal API

State stored in maps, lists, tuples

ok/err for error handling

Deterministic interaction with blockchain state

Architectural Patterns

Functional, immutable state

Decidable loops and conditions

Contract-to-contract calls

Error handling via ok/err

Structured storage via maps/tuples

Real World Architectures

STX token transfers

NFT minting/trading platforms

Decentralized voting/governance

Escrow contracts

Predictable DeFi protocols

Design Principles

Decidability and predictability

Functional programming approach

Integration with Bitcoin

Strong type system

Security-first contract design

Scalability Guide

Keep loops bounded

Optimize map/tuple usage

Deploy multiple small contracts instead of one monolith

Use off-chain indexing for analytics

Monitor execution via CLI

Migration Guide

Rewrite Solidity/EVM contracts in Clarity syntax

Replace dynamic loops with bounded expressions

Use define-public/define-private functions

Use maps/tuples for storage

Deploy on Stacks instead of Ethereum

Performance Notes

Deterministic execution ensures predictability

No gas estimation simplifies performance modeling

Execution is limited by Stacks node capabilities

Loops are bounded due to decidability

Efficient for small to medium on-chain apps

Security Notes

Strong typing prevents many runtime errors

Decidability ensures contracts behave as expected

Immutable constants protect critical values

Safe interaction with Bitcoin

Formal verification easier than general-purpose languages

Monitoring Analytics

Track public function calls

Monitor state changes in maps/tuples

Analyze error handling patterns

Integrate with Stacks testnet dashboards

Audit deterministic execution flows

Code Quality

Follow functional programming practices

Use ok/err consistently

Keep storage minimal

Document public/private functions

Unit-test deterministic outcomes

Practical Examples

STX token transfer contract

NFT minting and listing

Voting governance contract

Escrow with Bitcoin integration

Predictable DeFi interest protocol

Troubleshooting

Check Clarity syntax (Lisp parentheses)

Ensure correct type usage

Validate map and tuple structures

Test return patterns with ok/err

Verify Bitcoin integration endpoints

Testing Guide

Unit-test contracts using Clarity REPL

Simulate public/private function calls

Check deterministic return values

Validate map/tuple updates

Integrate with testnet for end-to-end testing

Deployment Options

Stacks testnet for development

Mainnet deployment for production

Dockerized CLI for CI/CD pipelines

Automated deployment scripts

Integration with frontend wallets for user access

Tools Ecosystem

Clarity CLI

Hiro Wallet

Stacks.js for frontend interaction

Stacks Testnet

Clarity REPL and VSCode plugin

Integrations

Stacks blockchain mainnet and testnet

Bitcoin for secure settlement

Frontend apps via Stacks.js

DeFi protocols and NFT marketplaces

Off-chain computation via oracles if needed

Productivity Tips

Leverage Clarity REPL for quick tests

Use constants for repeated values

Modularize functions

Monitor deterministic outputs

Document code and storage clearly

Challenges

Learning functional Lisp-like syntax

Integrating with Bitcoin securely

Bounded loops and decidability restrictions

Smaller community and resources

Limited libraries compared to Solidity

Learning Path

Learn Lisp-like syntax

Understand Clarity data types and functions

Practice public/private function writing

Deploy on Stacks testnet

Integrate with Bitcoin and frontend apps

Skill Improvement Plan

Week 1: Clarity syntax basics

Week 2: Public/private functions and constants

Week 3: Maps, lists, tuples, and storage

Week 4: Deploy testnet contracts

Week 5: Integrate with frontend and Bitcoin

Interview Questions

What is Clarity used for?

Explain the concept of decidability.

How does Clarity integrate with Bitcoin?

What are define-public and define-constant?

How does Clarity differ from Solidity?

Cheat Sheet

define-public -> external function

define-private -> internal function

define-constant -> immutable value

ok(...) -> success result

err(...) -> error result

Books

Mastering Clarity Smart Contracts

Building DeFi on Stacks

Clarity for Blockchain Developers

NFT Development with Clarity

Bitcoin-Integrated Smart Contracts

Tutorials

Getting started with Clarity

Build your first token contract

NFT minting on Stacks

Governance contract tutorial

Integrate Clarity with frontend apps

Official Docs

https://docs.stacks.co/docs/clarity/overview

https://github.com/hirosystems/clarity

Community Links

Stacks Discord

Hiro Forum

Clarity GitHub Discussions

YouTube tutorials by Hiro

Stacks developer events

Community Support

Hiro Systems Forum

Stacks Discord Community

GitHub Discussions for Clarity

YouTube tutorials by Hiro

Official Stacks Documentation

Monetization

Deploy DeFi contracts

NFT marketplaces

Governance solutions

Subscription-based apps on Stacks

Offer secure Bitcoin-integrated apps

Future Roadmap

Enhanced tooling and IDE support

Better testing frameworks

Expanded DeFi libraries

Improved Bitcoin integration

Growing Clarity developer community

When Not To Use

EVM-based projects

Non-Stacks blockchain deployments

Projects needing extensive third-party libraries

Developers unfamiliar with Lisp-like syntax

High-complexity contracts requiring dynamic execution

Final Summary

Clarity is a decidable, predictable smart contract language.

Used on Stacks blockchain with Bitcoin integration.

Ideal for secure DeFi, NFTs, and governance applications.

Functional, Lisp-like syntax with strong type safety.

Ensures auditable and deterministic contract execution.

Faq

Is Clarity Turing-complete?

No - it is decidable for predictable outcomes.

Can Clarity interact with Bitcoin?

Yes - through Stacks blockchain integration.

Which languages are similar to Clarity?

Lisp/Scheme-like syntax.

Can Clarity be used for NFTs?

Yes - supports minting and trading on Stacks.

Is Clarity safe for DeFi?

Yes - predictable and auditable contract execution.

Code Sample Descriptions

1

Clarity Simple Counter Contract

(define-data-var counter int 0)

(define-public (increment)
    (begin
        (var-set counter (+ (var-get counter) 1))
        (ok (var-get counter))))

(define-public (reset)
    (begin
        (var-set counter 0)
        (ok (var-get counter))))

A minimal Clarity contract defining a counter with increment and reset functionality.

Let’s Try →
2

Clarity Token Balance Store

(define-map balances principal int)

(define-public (credit user amount)
    (begin
        (map-set balances user (+ (default-to 0 (map-get? balances user)) amount))
        (ok true)))

(define-public (debit user amount)
    (let ((bal (default-to 0 (map-get? balances user))))
        (if (>= bal amount)
            (begin (map-set balances user (- bal amount)) (ok true))
            (err u100))))

Stores simple token balances with read, credit, and debit functions.

Let’s Try →
3

Clarity Ownership Module

(define-data-var owner principal tx-sender)

(define-public (set-owner new-owner)
    (begin
        (asserts! (is-eq tx-sender (var-get owner)) u403)
        (var-set owner new-owner)
        (ok true)))

Defines a simple owner pattern with update functionality.

Let’s Try →
4

Clarity Simple Voting System

(define-data-var votes int 0)

(define-public (vote)
    (begin
        (var-set votes (+ (var-get votes) 1))
        (ok (var-get votes))))

A basic voting module with upvote and total count.

Let’s Try →
5

Clarity Boolean Toggle

(define-data-var flag bool false)

(define-public (toggle)
    (begin
        (var-set flag (not (var-get flag)))
        (ok (var-get flag))))

A simple boolean on/off toggle stored on-chain.

Let’s Try →
6

Clarity Fixed Supply Token

(define-constant total-supply u1000000)
(define-map balances principal uint)

(define-public (init user)
    (begin
        (map-set balances user total-supply)
        (ok true)))

(define-public (transfer to amount)
    (let ((bal (default-to u0 (map-get? balances tx-sender))))
        (if (>= bal amount)
            (begin
                (map-set balances tx-sender (- bal amount))
                (map-set balances to (+ (default-to u0 (map-get? balances to)) amount))
                (ok true))
            (err u1))))

A simple fixed-supply token with balances and transfer.

Let’s Try →
7

Clarity Timelock Contract

(define-data-var unlock-height uint u0)
(define-data-var locked-value uint u0)

(define-public (lock value height)
    (begin
        (var-set locked-value value)
        (var-set unlock-height height)
        (ok true)))

(define-public (withdraw)
    (if (>= block-height (var-get unlock-height))
        (ok (var-get locked-value))
        (err u10)))

Locks a value until a given block height.

Let’s Try →
8

Clarity Allowlist Example

(define-map allowed principal bool)

(define-public (add user)
    (begin
        (map-set allowed user true)
        (ok true)))

(define-public (remove user)
    (begin
        (map-set allowed user false)
        (ok true)))

Stores allowed addresses with add/remove operations.

Let’s Try →
9

Clarity Simple Message Storage

(define-data-var message (string-ascii 50) "")

(define-public (set-message msg)
    (begin
        (var-set message msg)
        (ok msg)))

Stores a public on-chain message.

Let’s Try →
10

Clarity Key-Value Store

(define-map store int int)

(define-public (set-value key value)
    (begin
        (map-set store key value)
        (ok value)))

(define-read-only (get-value key)
    (default-to 0 (map-get? store key)))

Generic key-value mapping for int -> int.

Let’s Try →

Frequently Asked Questions about Clarity

What is Clarity?

Clarity is a decidable smart contract language used on the Stacks blockchain. It enables predictable and secure smart contracts without gas estimation or unpredictable behavior.

What are the primary use cases for Clarity?

Building secure DeFi protocols on Stacks. NFT minting and trading. On-chain governance contracts. Bitcoin-integrated smart contracts. Deterministic financial applications

What are the strengths of Clarity?

Predictable smart contract execution. High security with decidability. Strong type system prevents many bugs. Integrates with Bitcoin safely. Simplifies auditing and formal verification

What are the limitations of Clarity?

Limited to Stacks blockchain. Lisp-like syntax may have learning curve. Fewer libraries compared to Solidity/EVM. Not general-purpose outside Stacks. Smaller community and tooling ecosystem

How can I practice Clarity typing speed?

CodeSpeedTest offers 10+ real Clarity code examples for typing practice. You can measure your WPM, track accuracy, and improve your coding speed with guided exercises.

Learn Other Programming Languages

CReactPythonC++RustTypeScriptKotlinPHPJavaC#RubyMqlCqlN1qlCypherGremlinPartiqlHaskellElixirFsharpView all languages →
CodeSpeedTest

Improve your coding speed, code accuracy, and programming syntax WPM with practice sessions across 500+ programming languages.

Quick Links

HomeAboutFeaturesGetting StartedLanguages

Legal & Support

Pro ⚡ PricingContactPrivacy PolicyTerms of Service

Connect

CodeSpeedTest on GitHubCodeSpeedTest on TwitterEmail CodeSpeedTest

© 2026 CodeSpeedTest. All rights reserved.