# Finch on Arm Linux

## About this Install Guide
|  |  |
| --- | --- |
| Reading time: | 10 min |
| Last updated: | 4 Aug 2026 |

|  |  |
| --- | --- |
| Author: | Jason Andrews , Arm<br>[GitHub](https://github.com/jasonrandrews)<br>[LinkedIn](https://linkedin.com/in/jason-andrews-7b05a8) |
| Official docs: | [View](https://runfinch.com/docs/) |

This guide shows you how to install and use the tool with the most common configuration. For advanced options and complete reference information, see the official documentation. Some install guides also include optional next steps to help you explore related workflows or integrations.

[Finch](https://runfinch.com) is an open-source container development tool from Amazon Web Services (AWS). It offers a simple, Docker-compatible CLI powered by containerd and nerdctl. Designed for Linux, macOS, and Windows, Finch is especially useful on Arm-based systems for efficient container workflows.

In this guide, you’ll learn how to install Finch on Arm Linux distributions, specifically Amazon Linux 2023 and Ubuntu 24.04.

## Before you begin
Make sure you’re using a system running Arm Linux. You can use a physical Arm device, a cloud instance from AWS, Azure, Google Cloud Platform (GCP), Oracle Cloud Infrastructure (OCI), or an Arm-based virtual machine.

To confirm the architecture, run:

```
uname -m
```

The output should be `aarch64` for 64-bit Arm systems.

## Install Finch on Amazon Linux 2023 for Arm
Finch is available as an RPM package in the standard Amazon Linux 2023 repositories, making installation simple.

Install Finch using the package manager:

```
sudo yum install runfinch-finch -y
```

Enable and start the containerd service:

```
sudo systemctl start containerd
```

Check that the containerd service is running:

```
sudo systemctl status containerd
```

The output is similar to:

```
__output__
● containerd.service - containerd container runtime
__output__  Loaded: loaded (/usr/lib/systemd/system/containerd.service; disabled; preset: disabled)
__output__  Active: active (running) since Wed 2025-05-21 19:49:50 UTC; 40s ago
__output__    Docs: https://containerd.io
__output__  Process: 25839 ExecStartPre=/sbin/modprobe overlay (code=exited, status=0/SUCCESS)
__output__  Main PID: 25841 (containerd)
__output__   Tasks: 10
__output__  Memory: 160.5M
__output__     CPU: 1.771s
__output__  CGroup: /system.slice/containerd.service
          └─25841 /usr/bin/containerd
```

The `finch` command is now available in your PATH. You can now skip to the section on [verifying the Finch installation](https://learn.arm.com/install-guides/finch/#verify-the-finch-installation).

## Install Finch on Ubuntu 24.04 for Arm
Finch doesn’t currently provide a Debian package for Ubuntu, but you can install it manually using the following three steps.

### Install Finch dependencies
Install Nerdctl by following the instructions in the [Nerdctl install guide](https://learn.arm.com/install-guides/nerdctl/). Then, install the required tools:

```
sudo apt install -y \
  golang \
  make \
  build-essential
```

### Build and install Finch
Clone the Finch repository and build the binary:

```
git clone https://github.com/runfinch/finch.git
cd finch
git submodule update --init --recursive
make
sudo make install
```

### Configure Finch
Create the Finch configuration directories:

```
sudo mkdir -p /etc/finch
sudo mkdir -p /usr/libexec/finch
```

Create the Finch configuration file:

```
cat << EOF | sudo tee /etc/finch/finch.yaml > /dev/null
# cpus: the amount of vCPU to dedicate to the virtual machine. (required)
cpus: 2

# memory: the amount of memory to dedicate to the virtual machine. (required)
memory: 2GiB

# snapshotters: the snapshotters a user wants to use (the first snapshotter will be set as the default snapshotter)
snapshotters:
    - overlayfs

# dockercompat: a configuration parameter to activate finch functionality to accept Docker-like commands and arguments.
dockercompat: true
EOF
```

Configure Nerdctl:

```
sudo ln -sf $(which nerdctl) /usr/libexec/finch/nerdctl
```

After these steps, the `finch` command is available in your PATH.

## Verify the Finch installation
You can check the Finch version:

```
sudo finch --version
```

The output is similar to:

```
__output__
finch version v1.17.2
```

Run a container to confirm functionality:

```
sudo finch run --rm armswdev/uname
```

If you see the architecture printed, Finch is working correctly.

The output should be:

```
__output__
Architecture is aarch64
```

Print your local container images:

```
sudo finch images
```

The output is similar to:

```
__output__
REPOSITORY        TAG       IMAGE ID        CREATED           PLATFORM       SIZE       BLOB SIZE
__output__ armswdev/uname    latest    82762f30a4a3    43 seconds ago    linux/arm64    110.4MB    28.89MB
```

Use `sudo finch help` to explore available commands.

You are now ready to use Finch to run containers on your Arm Linux system.