Intro to AlgoKit

AlgoKit is a comprehensive software development kit designed to streamline and accelerate the process of building decentralized applications on the Algorand blockchain. At its core, AlgoKit features a powerful command-line interface (CLI) tool that provides developers with an array of functionalities to simplify blockchain development. Along with the CLI, AlgoKit offers a suite of libraries, templates, and tools that facilitate rapid prototyping and deployment of secure, scalable, and efficient applications. Whether you’re a seasoned blockchain developer or new to the ecosystem, AlgoKit offers everything you need to harness the full potential of Algorand’s impressive tech and innovative consensus algorithm.

AlgoKit CLI

AlgoKit CLI is a powerful set of command line tools for Algorand developers. Its goal is to help developers build and launch secure, automated, production-ready applications rapidly.

AlgoKit CLI commands

Here is the list of commands that you can use with AlgoKit CLI.

• Bootstrap - Bootstrap AlgoKit project dependencies
• Compile - Compile Algorand Python code
• Completions - Install shell completions for AlgoKit
• Deploy - Deploy your smart contracts effortlessly to various networks
• Dispenser - Fund your TestNet account with ALGOs from the AlgoKit TestNet Dispenser
• Doctor - Check AlgoKit installation and dependencies
• Explore - Explore Algorand Blockchains using lora
• Generate - Generate code for an Algorand project
• Goal - Run the Algorand goal CLI against the AlgoKit Sandbox
• Init - Quickly initialize new projects using official Algorand Templates or community provided templates
• LocalNet - Manage a locally sandboxed private Algorand network
• Project - Perform a variety of AlgoKit project workspace related operations like bootstrapping development environment, deploying smart contracts, running custom commands, and more
• Task - Perform a variety of useful operations like signing & sending transactions, minting ASAs, creating vanity address, and more, on the Algorand blockchain

To learn more about AlgoKit CLI, refer to the following resources:

AlgoKit CLI Documentation Learn more about using and configuring AlgoKit CLI

AlgoKit CLI Repo Explore the codebase and contribute to its development

Algorand Python

If you are a Python developer, you no longer need to learn a complex smart contract language to write smart contracts.

Algorand Python is a semantically and syntactically compatible, typed Python language that works with standard Python tooling and allows you to write Algorand smart contracts (apps) and logic signatures in Python. Since the code runs on the Algorand virtual machine(AVM), there are limitations and minor differences in behaviors from standard Python, but all code you write with Algorand Python is Python code.

Here is an example of a simple Hello World smart contract written in Algorand Python:

from algopy import ARC4Contract, String, arc4


class HelloWorld(ARC4Contract):

    @arc4.abimethod()
    def hello(self, name: String) -> String:
        return "Hello, " + name + "!"

To learn more about Algorand Python, refer to the following resources:

Algorand Python Documentation Learn more about the design and implementation of Algorand Python

Algorand Python Repo Explore the codebase and contribute to its development

Algorand TypeScript

If you are a TypeScript developer, you no longer need to learn a complex smart contract language to write smart contracts.

Algorand TypeScript is a semantically and syntactically compatible, typed TypeScript language that works with standard TypeScript tooling and allows you to write Algorand smart contracts (apps) and logic signatures in TypeScript. Since the code runs on the Algorand virtual machine(AVM), there are limitations and minor differences in behaviors from standard TypeScript, but all code you write with Algorand TypeScript is TypeScript code.

Here is an example of a simple Hello World smart contract written in Algorand TypeScript:

import { Contract } from '@algorandfoundation/algorand-typescript';

export class HelloWorld extends Contract {
  hello(name: string): string {
    return `Hello, ${name}`;
  }
}

To learn more about Algorand TypeScript, refer to the following resources:

Algorand TypeScript Documentation Learn more about the design and implementation of Algorand TypeScript

Algorand TypeScript Repo Explore the codebase and contribute to its development

AlgoKit Utils

AlgoKit Utils is a utility library recommended for you to use for all chain interactions like sending transactions, creating tokens(ASAs), calling smart contracts, and reading blockchain records. The goal of this library is to provide intuitive, productive utility functions that make it easier, quicker, and safer to build applications on Algorand. Largely, these functions wrap the underlying Algorand SDK but provide a higher-level interface with sensible defaults and capabilities for common tasks.

AlgoKit Utils is available in TypeScript and Python.

Capabilities

The library helps you interact with and develop against the Algorand blockchain with a series of end-to-end capabilities as described below:

• AlgorandClient - The key entrypoint to the AlgoKit Utils functionality
• Core capabilities
  • Client management - Creation of (auto-retry) algod, indexer and kmd clients against various networks resolved from environment or specified configuration
  • Account management - Creation and use of accounts including mnemonic, rekeyed, multisig, transaction signer (useWallet for dApps and Atomic Transaction Composer compatible signers), idempotent KMD accounts and environment variable injected
  • Algo amount handling - Reliable and terse specification of microAlgo and Algo amounts and conversion between them
  • Transaction management - Ability to send single, grouped or Atomic Transaction Composer transactions with consistent and highly configurable semantics, including configurable control of transaction notes (including ARC-0002), logging, fees, multiple sender account types, and sending behavior
• Higher-order use cases
  • App management - Creation, updating, deleting, calling (ABI and otherwise) smart contract apps and the metadata associated with them (including state and boxes)
  • App deployment - Idempotent (safely retryable) deployment of an app, including deploy-time immutability and permanence control and TEAL template substitution
  • ARC-0032 Application Spec client - Builds on top of the App management and App deployment capabilities to provide a high productivity application client that works with ARC-0032 application spec defined smart contracts (e.g. via Beaker)
  • Algo transfers - Ability to easily initiate algo transfers between accounts, including dispenser management and idempotent account funding
  • Automated testing - Terse, robust automated testing primitives that work across any testing framework (including jest and vitest) to facilitate fixture management, quickly generating isolated and funded test accounts, transaction logging, indexer wait management and log capture
  • Indexer lookups / searching - Type-safe indexer API wrappers (no more Record<string, any> pain), including automatic pagination control

To learn more about AlgoKit Utils, refer to the following resources:

Algorand Utils Typescript Documentation Learn more about the design and implementation of Algorand Utils

Algorand Utils Typescript Repo Explore the codebase and contribute to its development

Algorand Utils Python Documentation Learn more about the design and implementation of Algorand Utils

Algorand Utils Python Repo Explore the codebase and contribute to its development

AlgoKit LocalNet

The AlgoKit LocalNet feature allows you to manage (start, stop, reset, manage) a locally sandboxed private Algorand network. This allows you to interact with and deploy changes against your own Algorand network without needing to worry about funding TestNet accounts, whether the information you submit is publicly visible, or whether you are connected to an active Internet connection (once the network has been started).

AlgoKit LocalNet uses Docker images optimized for a great developer experience. This means the Docker images are small and start fast. It also means that features suited to developers are enabled, such as KMD (so you can programmatically get faucet private keys).

To learn more about AlgoKit Localnet, refer to the following resources:

AlgoKit Localnet Documentation Learn more about using and configuring AlgoKit Localnet

AlgoKit Localnet GitHub Repository Explore the source code and technical implementation details

AVM Debugger

The AlgoKit AVM VS Code debugger extension provides a convenient way to debug any Algorand Smart Contracts written in TEAL.

To learn more about the AVM debugger, refer to the following resources:

AVM Debugger Documentation Learn more about using and configuring the AVM Debugger

AVM Debugger Extension Repo Explore the AVM Debugger codebase and contribute to its development

Client Generator

The client generator generates a type-safe smart contract client for the Algorand Blockchain that wraps the application client in AlgoKit Utils and tailors it to a specific smart contract. It does this by reading an ARC-0032 application spec file and generating a client that exposes methods for each ABI method in the target smart contract, along with helpers to create, update, and delete the application.

To learn more about the client generator, refer to the following resources:

Client Generator TypeScript Documentation Learn more about the TypeScript client generator for Algorand smart contracts

Client Generator TypeScript Repo Explore the TypeScript client generator codebase and contribute to its development

Client Generator Python Documentation Learn more about the Python client generator for Algorand smart contracts

Client Generator Python Repo Explore the Python client generator codebase and contribute to its development

Testnet Dispenser

The AlgoKit TestNet Dispenser API provides functionalities to interact with the Dispenser service. This service enables users to fund and refund assets.

To learn more about the testnet dispenser, refer to the following resources:

Testnet Dispenser Documentation Learn more about using and configuring the AlgoKit TestNet Dispenser

Testnet Dispenser Repo Explore the technical implementation and contribute to its development

AlgoKit Tools and Versions

While AlgoKit as a collection was bumped to Version 3.0 on March 26, 2025, it is important to note that the individual tools in the kit are on different package version numbers. In the future this may be changed to epoch versioning so that it is clear that all packages are part of the same epoch release.

Tool	Repository	AlgoKit 3.0 Min Version
Command Line Interface (CLI)	algokit-cli	2.6.0
Utils (Python)	algokit-utils-py	4.0.0
Utils (TypeScript)	algokit-utils-ts	9.0.0
Client Generator (Python)	algokit-client-generator-py	2.1.0
Client Generator (TypeScript)	algokit-client-generator-ts	5.0.0
Subscriber (Python)	algokit-subscriber-py	1.0.0
Subscriber (TypeScript)	algokit-subscriber-ts	3.2.0
Puya Compiler	puya	4.5.3
Puya Compiler, TypeScript	puya-ts	1.0.0-beta.58
AVM Unit Testing (Python)	algorand-python-testing	0.5.0
AVM Unit Testing (TypeScript)	algorand-typescript-testing	1.0.0-beta.30
Lora the Explorer	algokit-lora	1.2.0
AVM VSCode Debugger	algokit-avm-vscode-debugger	1.1.5
Utils Add-On for TypeScript Debugging	algokit-utils-ts-debug	1.0.4
Base Project Template	algokit-base-template	1.1.0
Python Smart Contract Project Template	algokit-python-template	1.6.0
TypeScript Smart Contract Project Template	algokit-typescript-template	0.3.1
React Vite Frontend Project Template	algokit-react-frontend-template	1.1.1
Fullstack Project Template	algokit-fullstack-template	2.1.4

Install

Note

Refer to Troubleshooting for more details on mitigation of known edge cases when installing AlgoKit.

Prerequisites

The installation pre-requisites change depending on the method you use to install. Please refer to Installation Methods.

Depending on the features you choose to leverage from the AlgoKit CLI, additional dependencies may be required. The AlgoKit CLI will tell you if you are missing one for a given command. These optional dependencies are:

• Git: Essential for creating and updating projects from templates. Installation guide available at Git Installation.
• Docker: Necessary for running the AlgoKit LocalNet environment. Docker Compose version 2.5.0 or higher is required. See Docker Installation.
• Python: For those installing the AlgoKit CLI via pipx or building contracts using Algorand Python. Minimum required version is Python 3.12+ when working with Algorand Python. See Python Installation.
• Node.js: For those working on frontend templates or building contracts using Algorand TypeScript or TEALScript. Minimum required versions are Node.js v22 and npm v10. See Node.js Installation.

Note

If you have previously installed AlgoKit using pipx and would like to switch to a different installation method, please ensure that you first uninstall the existing version by running pipx uninstall algokit. Once uninstalled, you can follow the installation instructions for your preferred platform.

Cross-platform installation

AlgoKit can be installed using OS specific package managers, or using the python tool pipx. See below for specific installation instructions.

Installation Methods

• Windows
• Mac
• Linux
• Universal via pipx

Install AlgoKit on Windows

Note

AlgoKit is supported on Windows 10 1709 (build 16299) and later. We only publish an x64 binary, however it also runs on ARM devices by default using the built in x64 emulation feature.

1. Ensure prerequisites are installed

   • WinGet (should be installed by default on recent Windows 10 or later)
   • Git (or winget install git.git)
   • Docker (or winget install docker.dockerdesktop)

     Note

     See our LocalNet documentation for more tips on installing Docker on Windows

   • Microsoft C++ Build Tools

2. Install using winget

   winget install algokit

3. Verify installation

Maintenance

Some useful commands for updating or removing AlgoKit in the future.

• To update AlgoKit: winget upgrade algokit
• To remove AlgoKit: winget uninstall algokit

Install AlgoKit on Mac

Note

AlgoKit is supported on macOS Big Sur (11) and later for both x64 and ARM (Apple Silicon)

1. Ensure prerequisites are installed

• Homebrew
• Git (should already be available if brew is installed)
• Docker, (or brew install --cask docker)

  Note

  Docker requires MacOS 11+

1. Install using Homebrew

   brew install algorandfoundation/tap/algokit

2. Restart the terminal to ensure AlgoKit is available on the path

3. Verify installation

Maintenance

Some useful commands for updating or removing AlgoKit in the future.

• To update AlgoKit: brew upgrade algokit
• To remove AlgoKit: brew uninstall algokit

Install AlgoKit on Linux

Note

AlgoKit is compatible with Ubuntu 16.04 and later, Debian, RedHat, and any distribution that supports Snap, but it is only supported on x64 architecture; ARM is not supported.

1. Ensure prerequisites are installed

• Snap (should be installed by default on Ubuntu 16.04.4 LTS (Xenial Xerus) or later)
• Git
• Docker

1. Install using snap

   sudo snap install algokit --classic

   For detailed guidelines per each supported linux distro, refer to Snap Store.

2. Verify installation

Maintenance

Some useful commands for updating or removing AlgoKit in the future.

• To update AlgoKit: snap refresh algokit
• To remove AlgoKit: snap remove --purge algokit

Install AlgoKit with pipx on any OS

1. Ensure desired prerequisites are installed

• Python 3.10+
• pipx
• Git
• Docker

1. Install using pipx

   pipx install algokit

2. Restart the terminal to ensure AlgoKit is available on the path

3. Verify installation

Maintenance

Some useful commands for updating or removing AlgoKit in the future.

• To update AlgoKit: pipx upgrade algokit
• To remove AlgoKit: pipx uninstall algokit

Verify installation

Verify AlgoKit is installed correctly by running algokit --version and you should see output similar to:

algokit, version 1.0.1

Note

If you get receive one of the following errors:

• command not found: algokit (bash/zsh)
• The term 'algokit' is not recognized as the name of a cmdlet, function, script file, or operable program. (PowerShell)

Then ensure that algokit is available on the PATH by running pipx ensurepath and restarting the terminal.

It is also recommended that you run algokit doctor to verify there are no issues in your local environment and to diagnose any problems if you do have difficulties running AlgoKit. The output of this command will look similar to:

timestamp: 2023-03-27T01:23:45+00:00
AlgoKit: 1.0.1
AlgoKit Python: 3.11.1 (main, Dec 23 2022, 09:28:24) [Clang 14.0.0 (clang-1400.0.29.202)] (location: /Users/algokit/.local/pipx/venvs/algokit)
OS: macOS-13.1-arm64-arm-64bit
docker: 20.10.21
docker compose: 2.13.0
git: 2.37.1
python: 3.10.9 (location:  /opt/homebrew/bin/python)
python3: 3.10.9 (location:  /opt/homebrew/bin/python3)
pipx: 1.1.0
poetry: 1.3.2
node: 18.12.1
npm: 8.19.2
brew: 3.6.18

If you are experiencing a problem with AlgoKit, feel free to submit an issue via:
https://github.com/algorandfoundation/algokit-cli/issues/new
Please include this output, if you want to populate this message in your clipboard, run `algokit doctor -c`

Per the above output, the doctor command output is a helpful tool if you need to ask for support or raise an issue.

Troubleshooting

This section addresses specific edge cases and issues that some users might encounter when interacting with the CLI. The following table provides solutions to known edge cases:

Issue Description	OS(s) with observed behaviour	Steps to mitigate	References
This scenario may arise if installed python was build without --with-ssl flag enabled, causing pip to fail when trying to install dependencies.	Debian 12	Run sudo apt-get install -y libssl-dev to install the required openssl dependency. Afterwards, ensure to reinstall python with --with-ssl flag enabled. This includes options like building python from source code or using tools like pyenv.	GitHub Issue
poetry install invoked directly or via algokit project bootstrap all fails on Could NOT find PkgConfig (missing: PKG_CONFIG_EXECUTABLE).	MacOS >=14 using python 3.13 installed via homebrew	Install dependencies deprecated in 3.13 and latest MacOS versions via brew install pkg-config, delete the virtual environment folder and retry the poetry install command invocation.	N/A