Intro to AlgoKit | Algorand Developer Portal

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

Language Servers

The Algorand VS Code Language Extensions provide developers with enhanced capabilities to build Algorand smart contracts efficiently within Visual Studio Code. Designed to work alongside the standard Python and TypeScript language servers, these extensions extend core IDE functionality by adding Algorand-specific diagnostics, validation, and intelligent code actions. The Python extension integrates seamlessly with the official Python extension and automatically detects the PuyaPy environment to offer real-time contract-aware analysis and quick fixes, helping developers catch errors early and improve code quality. Similarly, the TypeScript extension supports Algorand’s specialized TypeScript and smart contract utilities, providing targeted diagnostics and validation in a familiar developer workflow. Both extensions simplify the development process by offering immediate feedback relevant to Algorand’s unique blockchain environment, accelerating learning and reducing common mistakes. Currently in beta, they require Visual Studio Code 1.80.0 or later and are designed to complement existing language tooling, making them essential tools for any developer working on Algorand smart contracts.

Algokit TypeScript Language Server Learn more about the TypeScript Language Server

Algokit Python Langauge Server Learn more about the Python Language Server

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.

Install

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.

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

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)
   • 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

1. Ensure prerequisites are installed

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

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

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

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

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: