# Finch on Arm Linux

## About this Install Guide

| Reading time:    | 10 min              |
|-------------------|---------------------|
| Last updated:     | 4 Aug 2026          |
| Author:           | Jason Andrews, Arm [GitHub](https://github.com/jasonrandrews) [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:

```bash
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:

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

Enable and start the containerd service:

```bash
sudo systemctl start containerd
```

Check that the containerd service is running:

```bash
sudo systemctl status containerd
```

The output is similar to:

```bash
__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
__output__           └─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](#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://www.example.com/install-guides/nerdctl/). Then, install the required tools:

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

### Build and install Finch

Clone the Finch repository and build the binary:

```bash
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:

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

Create the Finch configuration file:

```bash
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:

```bash
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:

```bash
sudo finch --version
```

The output is similar to:

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

Run a container to confirm functionality:

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

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

The output should be:

```bash
__output__ Architecture is aarch64
```

Print your local container images:

```bash
sudo finch images
```

The output is similar to:

```bash
__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.