Ubuntu

How to Install Arduino on Ubuntu 26.04, 24.04 and 22.04

Choose between Ubuntu's repository package, Snap, Flathub IDE builds, or Arduino's official AppImage, then configure dialout access, launch the IDE, and maintain or remove each method cleanly.

Last updatedAuthorJoshua JamesRead time11 minGuide typeUbuntu
Arduino and Ubuntu logos representing Arduino IDE installation on Ubuntu Linux

Installing Arduino IDE on Ubuntu is mostly a branch and update-channel decision before you connect a board. Ubuntu’s repository and Snap provide the legacy IDE 1.8.x branch, while Flathub and Arduino’s official AppImage cover IDE 2.x for users who want the newer editor.

The graphical Arduino IDE and Arduino CLI serve different workflows. If you need terminal-only board, library, and sketch automation, Arduino CLI is a separate tool with its own official Arduino CLI installation workflow.

Install Arduino IDE on Ubuntu

Choose one method and keep its update and removal commands with it. APT is the cleanest Ubuntu-managed path for IDE 1.8.19, Flatpak is the easiest package-managed IDE 2.x option, and the official AppImage is the direct Arduino IDE 2.x build for x86_64 desktops.

MethodChannelBranchUpdatesBest For
APT (Default Repository)Ubuntu ReposIDE 1.8.19Through APTDistro-tested package and USB helper script
SnapSnapcraftIDE 1.8.19Automatic Snap refreshesSnap users who accept community-maintained packaging
Flatpak (IDE 1.x)FlathubIDE 1.xThrough FlatpakFlatpak users who prefer the classic IDE
Flatpak (IDE 2.x)FlathubIDE 2.xThrough FlatpakPackage-managed modern IDE builds
AppImage (IDE 2.x)Arduino GitHub ReleasesIDE 2.xNamed updater and launcherOfficial x86_64 build; profile on 26.04/24.04

Arduino’s official Linux downloads are AppImage and ZIP archives from the Arduino software page, not an official DEB package. The AppImage gives Ubuntu users a single upstream executable with a repeatable checksum-checked updater, so it is the official-download path for this Ubuntu workflow.

For most users, the APT method is the simplest starting point when IDE 1.8.19 is enough, because it integrates with Ubuntu’s package management and includes the arduino-add-groups utility for USB permissions. Choose Flatpak IDE 2.x when you want package-managed IDE 2 updates, or choose the official AppImage when you want Arduino’s direct IDE 2 binary with a helper-owned update command.

Ubuntu 26.04 LTS, 24.04 LTS, and 22.04 LTS all provide Arduino IDE 1.8.19 through APT. The official AppImage path is for x86_64 desktop systems and needs the release-specific FUSE package shown in that method. On Ubuntu 26.04 and 24.04, it also needs the AppArmor compatibility profile shown below for Electron’s sandbox.

Install Arduino IDE via Ubuntu Repository

With the APT method, Arduino IDE installs directly from Ubuntu’s repository. This approach provides a stable package, tracks system updates, and includes helper scripts for configuring USB permissions.

Update Your System Packages

Before installing new software, first refresh your package index and upgrade existing packages. Doing so ensures you have the latest security patches and also prevents dependency conflicts:

sudo apt update && sudo apt upgrade

If your account cannot run sudo commands yet, follow our guide to add a user to sudoers on Ubuntu before continuing.

Install Arduino IDE from APT

The arduino package comes from Ubuntu’s Universe component. Standard desktop installs usually have Universe enabled; on minimal systems, enable the Universe repository on Ubuntu first if APT cannot locate the package.

Install Arduino IDE and its dependencies with APT:

sudo apt install arduino

This command installs Arduino IDE 1.8.19, Java libraries, and AVR board tooling such as avrdude, gcc-avr, and arduino-core-avr. ARM board cores are normally installed later through the IDE’s Boards Manager rather than by installing Ubuntu’s gcc-arm-none-eabi package manually.

The package also adds the arduino-add-groups utility for configuring USB permissions.

Configure USB Permissions

Arduino boards connect via USB serial ports, which require your user account to be a member of the dialout group. Without this permission, the IDE cannot upload sketches to your board. Run the included helper script to add your user to the required group:

sudo arduino-add-groups

After running this command, log out and log back in for the group membership to take effect. Alternatively, if you prefer the manual approach, you can add yourself to the dialout group:

sudo usermod -aG dialout "$USER"

Verify the APT Installation

To confirm that Arduino IDE installed correctly, check which packages were installed:

apt-cache policy arduino

Expected output on Ubuntu 26.04 looks like this:

arduino:
  Installed: 2:1.8.19+dfsg1-5
  Candidate: 2:1.8.19+dfsg1-5
  Version table:
 *** 2:1.8.19+dfsg1-5 500
        500 http://au.archive.ubuntu.com/ubuntu resolute/universe amd64 Packages
        100 /var/lib/dpkg/status

The mirror hostname can differ by region. Ubuntu 26.04 currently uses the -5 revision, 24.04 uses -2, and 22.04 uses -1; all three provide Arduino IDE 1.8.19.

Install Arduino IDE via Snap

Snap provides a store-managed Arduino IDE 1.8.19 build. This method is convenient if you already use Snap packages and accept the Snapcrafters-maintained package rather than Arduino’s official IDE 2.x binary.

Verify Snap Availability

By default, Ubuntu includes Snap on standard desktop installations. On minimal Ubuntu systems where the snap command is missing, install the Snap daemon first:

sudo apt install snapd

Install the Arduino Snap

Once Snap is available, install Arduino IDE using the following command:

sudo snap install arduino

To verify the installation was successful, list installed Snap packages:

snap list arduino

Expected output:

Name     Version  Rev  Tracking       Publisher      Notes
arduino  1.8.19   85   latest/stable  snapcrafters*  -

The Snap version of Arduino IDE is community-maintained by Snapcrafters and may lag behind official Arduino releases. The stable channel currently provides Arduino IDE 1.8.19, so choose Flatpak IDE 2.x or Arduino’s official AppImage if you need the modern IDE.

Configure USB Permissions for Snap

The current Arduino snap auto-connects raw-usb, while serial-port remains disconnected unless a matching serial slot exists. Verify the interface state after installation:

snap connections arduino | grep -E 'raw-usb|serial-port'
raw-usb      arduino:raw-usb      :raw-usb  -
serial-port  arduino:serial-port  -         -

USB serial uploads still need your Ubuntu account in the dialout group:

sudo usermod -aG dialout "$USER"

Once you log out and back in, the group changes will take effect.

Install Arduino IDE via Flatpak

With Flatpak, Arduino IDE runs with its own runtime libraries and store-managed updates. Flathub hosts both Arduino IDE 1.x for the classic interface and Arduino IDE 2.x for the modern interface.

Flatpak is not pre-installed on Ubuntu. If you have not set it up yet, follow our guide to install Flatpak on Ubuntu before continuing.

Enable the Flathub Repository

Add the Flathub repository at system scope if it is not already configured:

sudo flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo

Confirm that the remote exists before installing the app:

flatpak remotes --columns=name,options
flathub system

Install Arduino IDE 1.x with Flatpak

Arduino IDE 1.x provides the classic interface that many long-time users prefer. Flatpak may list runtimes, download sizes, and permissions before installation; review that prompt before confirming. To install the classic IDE, run:

sudo flatpak install flathub cc.arduino.arduinoide

Install Arduino IDE 2.x with Flatpak

Arduino IDE 2.x is a complete rewrite with a modern interface, code autocompletion, syntax highlighting, and an integrated live debugger. To install it, run:

sudo flatpak install flathub cc.arduino.IDE2

The Flatpak version of Arduino IDE 2.x is community-maintained and not officially supported by Arduino. For issues specific to the Flatpak wrapper, report them to the Flathub issue tracker rather than Arduino’s official support channels.

Configure USB Permissions for Flatpak

The Flathub manifests for both Arduino IDE 1.x and 2.x currently request devices=all, so do not add a redundant Flatpak device override. Your Ubuntu user still needs access to serial devices through the dialout group:

sudo usermod -aG dialout "$USER"

After logging out and back in, verify the Flatpak installation:

flatpak list --app --columns=name,application,version,installation | grep -i arduino

Expected output for IDE 2.x:

Arduino IDE	cc.arduino.IDE2	2.x.x	system

Once group membership has refreshed, reconnect the board and select the detected port from the IDE.

Install Arduino IDE via Official AppImage

Arduino’s official IDE 2.x Linux download is a 64-bit x86_64 AppImage. Use this method when you want Arduino’s direct upstream build without installing the Flathub wrapper. On non-x86_64 Ubuntu systems, use the APT package or a store method whose listing supports your architecture.

If AppImage files are new to you, the general AppImage on Ubuntu guide explains the format and FUSE requirement. The commands below are specific to Arduino IDE.

Install AppImage Dependencies

The updater uses curl to query GitHub, jq to select the current Linux AppImage asset, and FUSE to mount the AppImage at launch. Ubuntu 26.04 and 24.04 use the time64 FUSE compatibility package:

sudo apt install curl jq libfuse2t64

On Ubuntu 22.04, install the older package name instead:

sudo apt install curl jq libfuse2

If APT cannot locate the FUSE package on a minimal Ubuntu system, enable the Universe repository on Ubuntu first, then rerun the dependency command for your release.

Confirm that the two command-line tools are available before creating the updater:

command -v curl jq
/usr/bin/curl
/usr/bin/jq

Create the AppImage Updater

The following block creates an updater at /usr/local/bin/update-arduino-ide-appimage and a launcher at /usr/local/bin/arduino-ide-appimage. It refuses to overwrite unrelated files or symlinks at either path, downloads the latest stable Arduino IDE AppImage from GitHub Releases, verifies GitHub’s published SHA-256 digest when present, installs the executable to ~/Applications/arduino-ide-latest.AppImage, and leaves the normal launch command as arduino-ide-appimage.

updater_path=/usr/local/bin/update-arduino-ide-appimage
launcher_path=/usr/local/bin/arduino-ide-appimage

if { sudo test -e "$updater_path" || sudo test -L "$updater_path"; } && ! sudo grep -q 'LinuxCapable Arduino IDE AppImage updater' "$updater_path"; then
  printf 'Refusing to replace existing file or symlink: %s\n' "$updater_path" >&2
  printf 'Move or inspect that file before rerunning this setup block.\n' >&2
  false
elif { sudo test -e "$launcher_path" || sudo test -L "$launcher_path"; } && ! sudo grep -q 'LinuxCapable Arduino IDE AppImage launcher' "$launcher_path"; then
  printf 'Refusing to replace existing file or symlink: %s\n' "$launcher_path" >&2
  printf 'Move or inspect that file before rerunning this setup block.\n' >&2
  false
else
  sudo tee "$updater_path" > /dev/null <<'EOF'
#!/usr/bin/env bash
# LinuxCapable Arduino IDE AppImage updater
set -euo pipefail

if [[ ${EUID:-$(id -u)} -eq 0 ]]; then
  printf 'Run this updater as your normal user, not with sudo.\n' >&2
  exit 1
fi

for required_cmd in curl jq sha256sum install mktemp; do
  if ! command -v "$required_cmd" >/dev/null 2>&1; then
    printf 'Missing required command: %s\n' "$required_cmd" >&2
    exit 1
  fi
done

api_url="https://api.github.com/repos/arduino/arduino-ide/releases/latest"
app_dir="$HOME/Applications"
appimage_path="$app_dir/arduino-ide-latest.AppImage"
tmp_dir=''
cleanup() {
  [ -n "${tmp_dir:-}" ] && rm -rf -- "$tmp_dir"
}
trap cleanup EXIT HUP INT TERM

tmp_dir="$(mktemp -d)"
mkdir -p "$app_dir"

release_json="$(curl -fsSL "$api_url")"
version="$(jq -er '.tag_name' <<<"$release_json")"

if ! asset_info="$(jq -er '
  .assets
  | map(select(.name | test("^arduino-ide_[0-9]+(\\.[0-9]+)*_Linux_64bit\\.AppImage$")))
  | if length == 0 then empty else first | [.browser_download_url, (.digest // ""), .name] | @tsv end
' <<<"$release_json")"; then
  printf 'Could not find a Linux 64-bit Arduino IDE AppImage in the latest release.\n' >&2
  exit 1
fi

IFS=$'\t' read -r appimage_url digest asset_name <<<"$asset_info"

if [[ -z $appimage_url || -z $asset_name ]]; then
  printf 'GitHub returned an incomplete AppImage asset record.\n' >&2
  exit 1
fi

expected_hash=''
if [[ $digest == sha256:* ]]; then
  expected_hash="${digest#sha256:}"
fi

if [[ -n $expected_hash && -f $appimage_path ]]; then
  read -r current_hash _ < <(sha256sum "$appimage_path")
  if [[ $current_hash == "$expected_hash" ]]; then
    printf 'Arduino IDE %s AppImage is already current.\n' "$version"
    ls -lh "$appimage_path"
    exit 0
  fi
fi

tmp_file="$tmp_dir/$asset_name"
printf 'Downloading Arduino IDE %s AppImage...\n' "$version"
curl -fsSL --retry 3 --output "$tmp_file" "$appimage_url"

if [[ -n $expected_hash ]]; then
  printf '%s  %s\n' "$expected_hash" "$tmp_file" | sha256sum -c --status -
  printf 'Checksum verified.\n'
else
  printf 'No SHA-256 digest was published for %s; skipping checksum verification.\n' "$asset_name" >&2
fi

install -m 0755 "$tmp_file" "$appimage_path"
printf 'Installed %s\n' "$appimage_path"
ls -lh "$appimage_path"
EOF
  sudo chmod 755 "$updater_path"
  sudo tee "$launcher_path" > /dev/null <<'EOF'
#!/usr/bin/env bash
# LinuxCapable Arduino IDE AppImage launcher
set -euo pipefail

if [[ ${EUID:-$(id -u)} -eq 0 ]]; then
  printf 'Run Arduino IDE as your normal user, not with sudo.\n' >&2
  exit 1
fi

appimage_path="$HOME/Applications/arduino-ide-latest.AppImage"

if [[ ! -x "$appimage_path" ]]; then
  printf 'Arduino IDE AppImage is missing or not executable: %s\n' "$appimage_path" >&2
  printf 'Run update-arduino-ide-appimage first.\n' >&2
  exit 1
fi

exec "$appimage_path" "$@"
EOF
  sudo chmod 755 "$launcher_path"
fi

Download and Verify the AppImage

Confirm that both helper commands resolve from your PATH:

command -v update-arduino-ide-appimage arduino-ide-appimage
/usr/local/bin/update-arduino-ide-appimage
/usr/local/bin/arduino-ide-appimage

Run the updater as your normal user, not with sudo:

update-arduino-ide-appimage

Example output:

Downloading Arduino IDE 2.3.10 AppImage...
Checksum verified.
Installed /home/username/Applications/arduino-ide-latest.AppImage
-rwxr-xr-x 1 username username 193M Jun 19 11:34 /home/username/Applications/arduino-ide-latest.AppImage

If the installed AppImage already matches the latest published SHA-256 digest, the same command exits without downloading another copy:

Arduino IDE 2.3.10 AppImage is already current.
-rwxr-xr-x 1 username username 193M Jun 19 11:34 /home/username/Applications/arduino-ide-latest.AppImage

Add AppArmor Profile on Ubuntu 26.04 and 24.04

Ubuntu 26.04 and 24.04 restrict unprivileged user namespaces through AppArmor. Arduino IDE 2.x is an Electron app, so the AppImage needs a named compatibility profile with user namespace access. This profile is not AppArmor hardening and does not disable AppArmor globally; it gives the AppImage path its own profile instead of using sudo, a global sysctl change, or a persistent --no-sandbox launcher. Ubuntu 22.04 normally skips this step because the restriction is inactive on a default install.

. /etc/os-release

case "$VERSION_ID" in
  26.04|24.04)
    sudo install -d -m 0755 /etc/apparmor.d/local

    if [ -f /etc/apparmor.d/abi/5.0 ]; then
      apparmor_abi="5.0"
    elif [ -f /etc/apparmor.d/abi/4.0 ]; then
      apparmor_abi="4.0"
    else
      echo "No supported AppArmor ABI file found for this Arduino IDE profile." >&2
    fi

    if [ -n "${apparmor_abi:-}" ]; then
      sudo tee /etc/apparmor.d/local/arduino-ide-appimage > /dev/null <<'EOF'
# Site-specific Arduino IDE AppImage AppArmor additions.
EOF

      sudo tee /etc/apparmor.d/arduino-ide-appimage > /dev/null <<EOF
# This profile allows everything and only exists to give Arduino IDE AppImage
# a named AppArmor profile with user namespace access on Ubuntu.

abi <abi/${apparmor_abi}>,
include <tunables/global>

profile arduino-ide-appimage "@{HOME}/Applications/arduino-ide-latest.AppImage" flags=(unconfined) {
  userns,
  "@{HOME}/Applications/arduino-ide-latest.AppImage" mr,

  # Site-specific additions and overrides.
  include if exists <local/arduino-ide-appimage>
}
EOF

      sudo apparmor_parser -r /etc/apparmor.d/arduino-ide-appimage
      sudo aa-status | grep 'arduino-ide-appimage'
    fi
    ;;
  *)
    printf 'Ubuntu %s normally does not need this Arduino IDE AppImage profile.\n' "$VERSION_ID"
    ;;
esac

Expected output on Ubuntu 26.04 and 24.04 includes the loaded profile name. If you install the AppImage somewhere other than ~/Applications/arduino-ide-latest.AppImage, update both AppImage path lines in the profile before reloading it.

   arduino-ide-appimage

Configure USB Permissions for AppImage

The AppImage does not install Ubuntu group helpers, so add your account to dialout manually. This is still required for USB serial uploads:

sudo usermod -aG dialout "$USER"

Log out and back in before uploading sketches. Do not run the AppImage with sudo; fix the serial-device permission instead.

Launch Arduino IDE

Once the installation completes, launch Arduino IDE from your desktop menu or with the terminal command that matches your installation method. APT, Snap, and Flatpak add menu launchers. The AppImage method adds the terminal launcher arduino-ide-appimage.

Launch from the Applications Menu

Open Activities, type “Arduino” in the search field, and click the Arduino IDE icon. If you installed both IDE 1.x and 2.x through Flatpak, you will see two entries; select the version you want to use. This AppImage method does not create a menu entry by itself.

Launch from Terminal

Alternatively, terminal launch commands vary by installation method:

APT installation:

arduino

Snap installation:

snap run arduino

Flatpak Arduino IDE 1.x:

flatpak run cc.arduino.arduinoide

Flatpak Arduino IDE 2.x:

flatpak run cc.arduino.IDE2

AppImage Arduino IDE 2.x:

arduino-ide-appimage
Arduino IDE application icons for versions 1.x and 2.x in the Ubuntu applications menu
Application icons for Arduino IDE 1.x and 2.x in the Ubuntu menu
Arduino IDE 1.x default interface on first launch showing the classic editor layout
The classic IDE 1.x interface on first launch
Arduino IDE 2.x modern interface featuring dark theme and improved layout
Modern IDE 2.x interface with enhanced editor features

Troubleshooting Common Issues

Arduino Board Not Detected

When the IDE cannot detect your Arduino board, the most common cause is insufficient USB permissions. First, verify that your current login session includes the dialout group:

id -nG | tr ' ' '\n' | grep '^dialout$'
dialout

If dialout does not appear in the output, add yourself to the group and log out:

sudo usermod -aG dialout "$USER"

After logging back in, reconnect your Arduino board. Then, to verify the device is recognized, check the /dev directory:

ls /dev/ttyACM* /dev/ttyUSB* 2>/dev/null
/dev/ttyACM0

If this command shows devices like /dev/ttyACM0 or /dev/ttyUSB0, then your board is connected and recognized by the system.

Upload Fails with Permission Denied

Even after adding yourself to the dialout group, uploads may fail if you have not started a new login session. Remember that group memberships only take effect after logging out completely. If you are using a graphical session, logging out and back in should resolve this. For terminal sessions, you can verify your current group membership:

id

The output should include dialout in the groups list:

uid=1000(username) gid=1000(username) groups=1000(username),20(dialout),27(sudo)...

If dialout is missing from the current session after you already added the group, log out completely and sign in again.

Serial Monitor Shows Garbage Characters

If the Serial Monitor displays unreadable characters instead of expected output, verify that the baud rate in your sketch matches the baud rate selected in the Serial Monitor. The default is often 9600, while many projects use 115200 for faster communication.

AppImage Updater Cannot Find a Release

If the updater reports a missing command or cannot find an AppImage asset, first verify that the helper and its dependencies are available:

command -v update-arduino-ide-appimage arduino-ide-appimage curl jq
/usr/local/bin/update-arduino-ide-appimage
/usr/local/bin/arduino-ide-appimage
/usr/bin/curl
/usr/bin/jq

Then confirm that GitHub’s latest-release API is reachable from your system:

curl -fsSL https://api.github.com/repos/arduino/arduino-ide/releases/latest | jq -r '.tag_name'
2.3.10

If the API command fails, resolve the network, proxy, DNS, or GitHub access issue before rerunning update-arduino-ide-appimage. If the API responds but the helper still cannot find an asset, Arduino may have changed the Linux AppImage filename pattern in its latest release.

AppImage Fails to Launch

If the AppImage downloads but does not start, first confirm that the file exists and remains executable:

command -v arduino-ide-appimage
ls -lh "$HOME/Applications/arduino-ide-latest.AppImage"
test -x "$HOME/Applications/arduino-ide-latest.AppImage" && echo "AppImage is executable"
/usr/local/bin/arduino-ide-appimage
-rwxr-xr-x 1 username username 193M Jun 19 11:34 /home/username/Applications/arduino-ide-latest.AppImage
AppImage is executable

If the executable bit is missing, restore it:

chmod 755 "$HOME/Applications/arduino-ide-latest.AppImage"

Next, confirm the FUSE compatibility package for your Ubuntu release. On Ubuntu 26.04 and 24.04, check libfuse2t64:

apt-cache policy libfuse2t64

On Ubuntu 22.04, check libfuse2 instead:

apt-cache policy libfuse2

Ubuntu uses AppArmor, and recent releases can restrict unprivileged user namespaces. A harmless fusermount3 audit line can appear even when the AppImage starts. Treat AppArmor as the blocker only when a fresh denial names userns_create, unprivileged_userns, chrome-sandbox, or the Arduino AppImage path at the same time as the failed launch:

sudo journalctl -k --since "-5 minutes" --no-pager | grep -Ei 'apparmor|userns|arduino|AppImage|chrome-sandbox'

If Ubuntu 26.04 or 24.04 shows that denial, rerun the AppArmor profile step from the AppImage method, then reload and confirm the profile:

sudo apparmor_parser -r /etc/apparmor.d/arduino-ide-appimage
sudo aa-status | grep 'arduino-ide-appimage'

Do not disable AppArmor globally, run the AppImage with sudo, or make --no-sandbox your normal launcher. Use the profile only when the denial matches this AppImage launch path.

After correcting the executable bit, FUSE package, or AppArmor profile, launch Arduino IDE again from Activities or a desktop terminal:

arduino-ide-appimage

Manage Arduino IDE

Update Arduino IDE

Each installation method uses its own update path:

APT installation:

sudo apt update && sudo apt install --only-upgrade arduino

Snap installation:

sudo snap refresh arduino

Flatpak IDE 1.x installation:

sudo flatpak update cc.arduino.arduinoide

Flatpak IDE 2.x installation:

sudo flatpak update cc.arduino.IDE2

AppImage installation:

update-arduino-ide-appimage

When the AppImage already matches the latest published checksum, the helper exits without replacing the file:

Arduino IDE 2.3.10 AppImage is already current.
-rwxr-xr-x 1 username username 193M Jun 19 11:34 /home/username/Applications/arduino-ide-latest.AppImage

Remove Arduino IDE

Use the removal command that matches the installation method you chose.

APT removal:

sudo apt remove arduino

After removing the package, simulate the unused-dependency cleanup before accepting it:

sudo apt autoremove --simulate

If the simulation only lists packages you no longer need, run the cleanup:

sudo apt autoremove

Snap removal:

sudo snap remove --purge arduino

Flatpak removal (IDE 1.x):

sudo flatpak uninstall cc.arduino.arduinoide

Flatpak removal (IDE 2.x):

sudo flatpak uninstall cc.arduino.IDE2

AppImage removal:

rm -f "$HOME/Applications/arduino-ide-latest.AppImage"
if sudo test -f /usr/local/bin/update-arduino-ide-appimage && sudo grep -q 'LinuxCapable Arduino IDE AppImage updater' /usr/local/bin/update-arduino-ide-appimage; then
  sudo rm -f /usr/local/bin/update-arduino-ide-appimage
fi
if sudo test -f /usr/local/bin/arduino-ide-appimage && sudo grep -q 'LinuxCapable Arduino IDE AppImage launcher' /usr/local/bin/arduino-ide-appimage; then
  sudo rm -f /usr/local/bin/arduino-ide-appimage
fi
profile_path=/etc/apparmor.d/arduino-ide-appimage
local_profile_path=/etc/apparmor.d/local/arduino-ide-appimage
if sudo test -f "$profile_path" && sudo grep -q 'profile arduino-ide-appimage' "$profile_path"; then
  sudo apparmor_parser -R "$profile_path" 2>/dev/null || true
  sudo rm -f "$profile_path"
fi
if sudo test -f "$local_profile_path" && sudo grep -q 'Arduino IDE AppImage' "$local_profile_path"; then
  sudo rm -f "$local_profile_path"
fi
hash -r
test ! -e "$HOME/Applications/arduino-ide-latest.AppImage" && ! command -v update-arduino-ide-appimage >/dev/null && ! command -v arduino-ide-appimage >/dev/null && ! sudo test -e "$profile_path" && ! sudo test -e "$local_profile_path" && echo "AppImage, launcher, updater, and AppArmor profile removed"

Arduino IDE stores sketches, board cores, libraries, preferences, and Flatpak app data in your home directory. Back up sketches and custom libraries before deleting these paths.

Review matching user-data paths before deleting them:

printf '%s\n' "$HOME/Arduino" "$HOME/.arduino15" "$HOME/.arduinoIDE" "$HOME/.var/app/cc.arduino.IDE2" "$HOME/.var/app/cc.arduino.arduinoide" | while IFS= read -r path; do
  [ -e "$path" ] && printf '%s\n' "$path"
done

After backing up anything you want to keep, remove those directories:

rm -rf "$HOME/Arduino" "$HOME/.arduino15" "$HOME/.arduinoIDE" "$HOME/.var/app/cc.arduino.IDE2" "$HOME/.var/app/cc.arduino.arduinoide"

Package removal does not undo the dialout membership you added for USB uploads. If Arduino was the only reason you needed serial-device access, remove your account from the group and start a new login session:

sudo gpasswd -d "$USER" dialout

Finally, clean up unused Flatpak runtimes after removing Flatpak apps:

sudo flatpak uninstall --unused

Official Arduino resources are useful after installation for board setup, language reference, release notes, and project examples:

Conclusion

Arduino IDE on Ubuntu is ready once the chosen package or AppImage launches, your account belongs to dialout, and the board appears as a serial device. Install board cores and libraries from inside the IDE, then keep updates on the same channel: APT or Snap for the classic IDE, and Flatpak or the official AppImage for IDE 2.x.

Share this guide

Help another Linux user troubleshoot faster

Share this guide with someone troubleshooting Linux systems or saving it for later.

BlueskyRedditXTumblrFacebookLinkedIn
Follow LinuxCapable

Want more LinuxCapable guides in Google?

Add LinuxCapable as a preferred source so Google can show our tutorials more often in Top Stories and mark them as preferred in AI Mode and AI Overviews when relevant.

Add LinuxCapable as a preferred source on Google
Search LinuxCapable

Need another guide?

Search LinuxCapable for package installs, commands, troubleshooting, and follow-up guides related to what you just read.

Found this guide useful?

Support LinuxCapable to keep tutorials free and up to date.

Buy me a coffeeBuy me a coffee
Before commenting, please review our Comments Policy.
Formatting tips for your comment

You can use basic HTML to format your comment. Useful tags currently allowed in published comments:

You type Result
<code>command</code> command
<strong>bold</strong> bold
<em>italic</em> italic
<a href="https://example.com">link</a> link
<blockquote>quote</blockquote> quote block

Add to the discussion

Questions, fixes, command output, and version notes help keep this guide current.

Verify before posting: