How to Install Kdenlive on Ubuntu 26.04, 24.04 and 22.04

Kdenlive gives Ubuntu users a full timeline editor for cutting footage, working with multiple audio and video tracks, applying effects, and rendering finished projects without moving to a proprietary editor. If you want to install Kdenlive on Ubuntu, the best method depends on whether you want Kdenlive’s official Linux packages, Ubuntu’s repository build, or a Snap Store alternative.

The current Kdenlive upstream release moves faster than Ubuntu LTS packages. AppImage and Flatpak are the Linux packages supported by the Kdenlive team, while Snap and APT remain useful when those update models fit your desktop better. The commands cover each path for Ubuntu 26.04, 24.04, and 22.04.

Install Kdenlive on Ubuntu

Choose the Kdenlive Installation Method on Ubuntu

Method	Source and Status	Update Path	Best Fit
AppImage	KDE download page, official Kdenlive Linux package	`update-kdenlive-appimage`	Most desktop users who want the newest stable upstream build without changing package sources
Flatpak	Flathub, official Kdenlive Linux package	`flatpak update`	Users who already use Flathub or want store-managed KDE runtime updates
Snap stable	Snapcraft, KDE verified publisher account	`snap refresh`	Ubuntu users who specifically prefer Snap and accept that channel versions can lag upstream
Snap beta	Snapcraft beta channel	`snap refresh --channel=beta`	Testing Snap revisions before they reach the stable channel
APT package	Ubuntu Universe, distro repository package	`apt upgrade`	Users who prefer Ubuntu repository packages and do not need the newest Kdenlive branch

For most Ubuntu desktops, AppImage or Flatpak should be the first choice because Kdenlive’s Linux installation documentation names those as the officially supported package formats. The 26.04.1 release also includes an upstream security fix for malicious project files, so check that your chosen package source offers 26.04.1 or later if you open .kdenlive project files from outside your own trusted workflow.

The older Kdenlive stable and development PPAs are no longer documented as installation methods. The Kdenlive Launchpad team page says those PPAs stopped receiving updates in May 2024, and Kdenlive’s installation documentation says PPA packages are no longer supported.

Update Ubuntu Package Metadata

Refresh package metadata before installing packages from Ubuntu’s enabled sources:

sudo apt update

Install Kdenlive with APT on Ubuntu

The APT method installs Kdenlive from Ubuntu’s Universe component. It is the lowest-maintenance option, but it follows the Ubuntu release cadence rather than the newest upstream Kdenlive release. Prefer AppImage or Flatpak when you need Kdenlive-team-supported Linux packages or the latest upstream security fixes.

sudo apt install kdenlive mediainfo

Confirm the package candidate and installed source:

apt-cache policy kdenlive

Install Kdenlive AppImage on Ubuntu

KDE publishes the stable x86_64 Kdenlive AppImage as an official Linux package. The helper below resolves the latest stable AppImage from KDE’s download directory, verifies the matching SHA256 file, installs it under /opt/kdenlive-appimage, creates a kdenlive-appimage launcher, extracts Kdenlive’s bundled desktop icon, and adds a desktop entry that GNOME can match to the running window. For a broader overview of this package format, see our guide to install AppImage apps on Ubuntu.

Install AppImage Prerequisites for Kdenlive

Install curl, the Qt/OpenGL runtime libraries Kdenlive’s AppImage expects from the host system, and the FUSE 2 compatibility package required by many AppImages. Ubuntu 26.04 and 24.04 use libfuse2t64, while Ubuntu 22.04 uses libfuse2.

sudo apt install curl libopengl0 libxcb-cursor0
. /etc/os-release
case "$VERSION_ID" in
  26.04|24.04)
    sudo apt install libfuse2t64
    ;;
  22.04)
    sudo apt install libfuse2
    ;;
  *)
    echo "Install your release's FUSE 2 compatibility package before continuing."
    ;;
esac

Create the Kdenlive AppImage Update Helper

Create a reusable update-kdenlive-appimage command. It checks KDE’s stable AppImage directory, compares the installed file with the newest available version, downloads the AppImage and its SHA256 file to a temporary location, verifies the checksum, and replaces the installed AppImage only after those checks succeed. It also refreshes the wrapper, desktop entry, and icon during no-op checks so an existing install keeps working application-menu and dock icons.

sudo tee /usr/local/bin/update-kdenlive-appimage > /dev/null <<'SCRIPT_EOF'
#!/usr/bin/env bash
set -euo pipefail

if [ "$(id -u)" -eq 0 ]; then
  echo "Run this command as your regular user; it will ask for sudo when needed."
  exit 1
fi

if [ "$(uname -m)" != "x86_64" ]; then
  echo "The upstream Kdenlive AppImage method currently targets x86_64 systems."
  exit 1
fi

CHECK_ONLY=0
case "${1:-}" in
  --check)
    CHECK_ONLY=1
    ;;
  "")
    ;;
  *)
    echo "Usage: update-kdenlive-appimage [--check]"
    exit 1
    ;;
esac

for cmd in curl dpkg-query find grep readlink sed sort mktemp install sha256sum; do
  if ! command -v "$cmd" >/dev/null 2>&1; then
    echo "Error: $cmd is required but not installed."
    echo "Install the AppImage prerequisites, then rerun this command."
    exit 1
  fi
done

BASE_URL="https://download.kde.org/stable/kdenlive"
TARGET_DIR="/opt/kdenlive-appimage"
CURRENT_LINK="$TARGET_DIR/kdenlive.AppImage"
ICON_NAME="kdenlive-appimage"
DESKTOP_ID="org.kde.kdenlive"
DESKTOP_FILE="/usr/share/applications/$DESKTOP_ID.desktop"
LEGACY_DESKTOP_FILE="/usr/share/applications/kdenlive-appimage.desktop"
ICON_THEME_DIR="/usr/share/icons/hicolor"

install_desktop_integration() {
  local appimage_path=$1
  local extract_dir icon_count icon_ext icon_file icon_target_dir rel_dir

  printf '%s\n' '#!/usr/bin/env bash' 'exec /opt/kdenlive-appimage/kdenlive.AppImage "$@"' | sudo tee /usr/local/bin/kdenlive-appimage >/dev/null
  sudo chmod 0755 /usr/local/bin/kdenlive-appimage

  if dpkg-query -S "$DESKTOP_FILE" >/dev/null 2>&1 && ! grep -q '^Exec=/usr/local/bin/kdenlive-appimage' "$DESKTOP_FILE" 2>/dev/null; then
    echo "A package-managed Kdenlive desktop entry already exists at $DESKTOP_FILE."
    echo "Remove the APT Kdenlive package or use only one Kdenlive installation method before installing the AppImage desktop launcher."
    exit 1
  fi

  extract_dir="$(mktemp -d)"
  if ! (cd "$extract_dir" && "$appimage_path" --appimage-extract usr/share/icons >/dev/null); then
    rm -rf "$extract_dir"
    echo "Could not extract the Kdenlive icon from the AppImage."
    exit 1
  fi

  icon_count=0
  while IFS= read -r icon_file; do
    rel_dir="${icon_file#"$extract_dir/squashfs-root/usr/share/icons/hicolor/"}"
    rel_dir="${rel_dir%/apps/*}"
    icon_ext="${icon_file##*.}"

    case "$rel_dir" in
      scalable|[0-9]*x[0-9]*)
        ;;
      *)
        continue
        ;;
    esac

    case "$icon_ext" in
      png|svg|svgz|xpm)
        ;;
      *)
        continue
        ;;
    esac

    icon_target_dir="$ICON_THEME_DIR/$rel_dir/apps"
    sudo install -d -m 0755 "$icon_target_dir"
    sudo install -m 0644 "$icon_file" "$icon_target_dir/$ICON_NAME.$icon_ext"
    icon_count=$((icon_count + 1))
  done < <(find "$extract_dir/squashfs-root/usr/share/icons/hicolor" -type f -path '*/apps/kdenlive.*' | sort -V)

  rm -rf "$extract_dir"

  if [ "$icon_count" -eq 0 ]; then
    echo "Could not find a Kdenlive application icon inside the AppImage."
    exit 1
  fi

  sudo install -d -m 0755 /usr/share/applications
  sudo tee "$DESKTOP_FILE" >/dev/null <<DESKTOP_EOF
[Desktop Entry]
Name=Kdenlive AppImage
Comment=Edit video with Kdenlive
Exec=/usr/local/bin/kdenlive-appimage %F
TryExec=/usr/local/bin/kdenlive-appimage
Icon=$ICON_NAME
Type=Application
Categories=Qt;KDE;AudioVideo;AudioVideoEditing;
MimeType=application/x-kdenlive;video/mp4;video/x-matroska;video/x-msvideo;video/quicktime;
StartupWMClass=kdenlive
StartupNotify=true
DESKTOP_EOF
  sudo rm -f "$LEGACY_DESKTOP_FILE" /usr/local/share/applications/kdenlive-appimage.desktop
  sudo update-desktop-database /usr/share/applications >/dev/null 2>&1 || true
  sudo update-desktop-database /usr/local/share/applications >/dev/null 2>&1 || true
  if command -v gtk-update-icon-cache >/dev/null 2>&1; then
    sudo gtk-update-icon-cache -q "$ICON_THEME_DIR" >/dev/null 2>&1 || true
  fi
}

printf '%s\n' "Checking KDE stable AppImage directory..."
SERIES="$(curl -fsSL "$BASE_URL/" | grep -oE 'href="[0-9]+\.[0-9]+/"' | sed -E 's#href="([0-9]+\.[0-9]+)/"#\1#' | sort -V | tail -n 1)"
if [ -z "$SERIES" ]; then
  echo "Could not detect the latest Kdenlive stable series."
  exit 1
fi

APPIMAGE_NAME="$(curl -fsSL "$BASE_URL/$SERIES/linux/" | grep -oE 'kdenlive-[0-9]+\.[0-9]+(\.[0-9]+)?-x86_64\.AppImage' | sort -V | tail -n 1)"
if [ -z "$APPIMAGE_NAME" ]; then
  echo "Could not find a matching x86_64 Kdenlive AppImage."
  exit 1
fi

APPIMAGE_URL="$BASE_URL/$SERIES/linux/$APPIMAGE_NAME"
VERSION="$(printf '%s\n' "$APPIMAGE_NAME" | sed -E 's/^kdenlive-([0-9]+\.[0-9]+(\.[0-9]+)?)-x86_64\.AppImage$/\1/')"
TARGET_FILE="$TARGET_DIR/$APPIMAGE_NAME"

CURRENT_VERSION="none"
if [ -e "$CURRENT_LINK" ] || [ -L "$CURRENT_LINK" ]; then
  CURRENT_TARGET="$(readlink -f "$CURRENT_LINK" 2>/dev/null || true)"
  CURRENT_BASE="${CURRENT_TARGET##*/}"
  CURRENT_VERSION="$(printf '%s\n' "$CURRENT_BASE" | sed -nE 's/^kdenlive-([0-9]+\.[0-9]+(\.[0-9]+)?)-x86_64\.AppImage$/\1/p')"
  CURRENT_VERSION="${CURRENT_VERSION:-installed}"
fi

printf 'Current version: %s\n' "$CURRENT_VERSION"
printf 'Latest version:  %s\n' "$VERSION"

if [ "$CHECK_ONLY" -eq 1 ]; then
  printf 'Latest AppImage URL: %s\n' "$APPIMAGE_URL"
  printf 'Checksum file:      %s.sha256\n' "$APPIMAGE_URL"
  curl -fsSL "$APPIMAGE_URL.sha256" | sed -n '1p'
  printf '\n'
  echo "Check-only mode; no files changed."
  exit 0
fi

if [ "$CURRENT_VERSION" = "$VERSION" ] && [ -x "$CURRENT_LINK" ]; then
  install_desktop_integration "$CURRENT_LINK"
  echo "Already up to date. Desktop entry and icon refreshed."
  exit 0
fi

TMP_DIR="$(mktemp -d)"
trap 'rm -rf "$TMP_DIR"' EXIT

printf 'Downloading %s\n' "$APPIMAGE_URL"
curl -fL --progress-bar -o "$TMP_DIR/$APPIMAGE_NAME" "$APPIMAGE_URL"
curl -fsSL -o "$TMP_DIR/$APPIMAGE_NAME.sha256" "$APPIMAGE_URL.sha256"
test -s "$TMP_DIR/$APPIMAGE_NAME"
(cd "$TMP_DIR" && sha256sum -c "$APPIMAGE_NAME.sha256")

sudo install -d -m 0755 "$TARGET_DIR"
sudo install -m 0755 "$TMP_DIR/$APPIMAGE_NAME" "$TARGET_FILE"
sudo ln -sfn "$TARGET_FILE" "$CURRENT_LINK"
install_desktop_integration "$TARGET_FILE"

echo "Installed Kdenlive AppImage $VERSION."
echo "Launch command: kdenlive-appimage"
SCRIPT_EOF

Make the helper executable and confirm the shell can find it:

sudo chmod 0755 /usr/local/bin/update-kdenlive-appimage
command -v update-kdenlive-appimage

/usr/local/bin/update-kdenlive-appimage

Run the helper in check-only mode to confirm it can resolve the latest AppImage and checksum file before it changes anything:

update-kdenlive-appimage --check

Download or Update the Kdenlive AppImage

Use the same helper for the first AppImage install and later AppImage updates:

update-kdenlive-appimage

The helper prints the current installed version, the latest version found on KDE’s stable download server, and either installs the newer AppImage or stops with Already up to date. when no replacement is needed. Even during that no-op path, it refreshes the wrapper, desktop entry, and menu icon.

Install Kdenlive with Flatpak on Ubuntu

Flatpak is not pre-installed on Ubuntu. If you have not set it up yet, install it with sudo apt install flatpak and restart your session before continuing. For detailed setup including the Flathub repository, follow our Flatpak installation guide for Ubuntu.

Add Flathub at system scope, then install the Kdenlive Flatpak. This is the other Kdenlive-team-supported Linux package format. The current Flathub metadata grants broad filesystem and device access for media editing, so treat this method mainly as a packaging and update choice rather than strict isolation.

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

Verify the installed Flatpak record:

flatpak info org.kde.kdenlive | grep -E '^[[:space:]]*(ID|Ref|Arch|Branch|Version|Origin|Installation):'

Install Kdenlive Stable Snap on Ubuntu

The Kdenlive Snap appears under the verified KDE publisher account on Snapcraft, but Kdenlive’s own Linux documentation names AppImage and Flatpak as the supported package formats. Use Snap when you specifically want Snap confinement and automatic refresh behavior, and check the channel version before relying on it for the newest upstream release.

command -v snap || sudo apt install snapd

Install the stable Snap channel:

sudo snap install kdenlive

Check the installed Snap and the active channel:

snap list kdenlive
snap info kdenlive

Install Kdenlive Beta Snap on Ubuntu

Use the beta channel only if you want to test newer Snap revisions before they move to stable. Channel versions can differ by architecture, so check snap info kdenlive before switching an existing project workstation.

sudo snap install kdenlive --channel=beta

If Kdenlive is already installed as a Snap, switch it to beta with snap refresh instead:

sudo snap refresh kdenlive --channel=beta

Return to stable later with the matching channel switch:

sudo snap refresh kdenlive --channel=stable

Check Kdenlive Source Build Support on Ubuntu

The current KDE build documentation is a developer workflow, not a simple all-version Ubuntu install method. It lists Ubuntu 25.10 or later as the supported Ubuntu-family baseline and requires Qt 6.6 or newer, KDE Frameworks 6.3 or newer, and MLT 7.28 or newer. Ubuntu 26.04 is the only covered LTS release close to those dependency floors through its repositories, while Ubuntu 24.04 and 22.04 do not provide the current KF6 and MLT stack needed for the latest Kdenlive source tree.

Use the KDE Kdenlive build documentation when you need a development build, patches, or debugging symbols. Do not treat the current source tree as a normal copy-paste install path unless you are prepared to manage KDDockWidgets, MLT, and KDE dependency work beyond a routine desktop install. For normal editing work on Ubuntu 24.04 or 22.04, use the AppImage, Flatpak, or Snap methods above instead of trying to compile the current branch against older LTS libraries.

Launch Kdenlive on Ubuntu

Kdenlive needs a normal graphical desktop session. The terminal command depends on the package source you installed.

Install Method	Terminal Launch Command	Desktop Menu Entry
APT package	`kdenlive`	Kdenlive
AppImage helper	`kdenlive-appimage`	Kdenlive AppImage
Flatpak	`flatpak run org.kde.kdenlive`	Kdenlive
Snap	`snap run kdenlive`	Kdenlive

From the desktop, open the application menu or Activities overview, search for Kdenlive, and select the entry created by your package source.

Get Started with Kdenlive on Ubuntu

Create a Project in Kdenlive

Start with a project profile that matches your footage, such as 1080p at 30 FPS or 4K at 60 FPS. Matching the project profile early keeps timeline previews and final renders closer to the source material.

Import Media into Kdenlive

Open the Project Bin area.
Select Add Clip or Folder.
Choose your video, audio, or image files.
Drag the imported clips from the Project Bin to the timeline.

Use Proxy Clips for Large Kdenlive Projects

Proxy clips help when high-resolution footage stutters during editing. Open the project settings, enable proxy clips, and let Kdenlive generate lighter preview files while keeping the original media for the final render.

Render a Kdenlive Project on Ubuntu

Select Render from the toolbar.
Choose the output format and preset that matches your target platform.
Set the output filename and destination folder.
Select Render to File and wait for the job to finish.

Update or Remove Kdenlive on Ubuntu

Update Kdenlive on Ubuntu

Use the update command that matches the package source you chose:

Install Method	Update Command	Notes
APT package	`sudo apt upgrade`	Updates Kdenlive when Ubuntu publishes a package update for your release.
AppImage helper	`update-kdenlive-appimage`	Checks KDE’s stable AppImage directory, verifies the SHA256 file, replaces the AppImage when a newer stable file exists, and refreshes the desktop entry and icon.
Flatpak	`sudo flatpak update org.kde.kdenlive -y`	Updates the Kdenlive Flatpak and any required runtime changes.
Snap stable	`sudo snap refresh kdenlive`	Refreshes the installed Snap on its current channel.
Snap beta	`sudo snap refresh kdenlive --channel=beta`	Keeps the Snap on beta after refreshes.

Remove APT Kdenlive on Ubuntu

Remove the Ubuntu repository package with APT. If mediainfo was already installed for another workflow before you installed Kdenlive, leave that package out of the removal command. For a deeper package-cleanup workflow, see our guide to remove packages on Ubuntu from the command line.

sudo apt remove kdenlive mediainfo

Remove Kdenlive AppImage on Ubuntu

The next commands delete only the AppImage paths, launcher, desktop entry, and icon files created by the helper above. Back up custom launchers first if you edited them manually.

sudo rm -rf /opt/kdenlive-appimage
sudo rm -f /usr/local/bin/kdenlive-appimage /usr/local/bin/update-kdenlive-appimage
if grep -q '^Exec=/usr/local/bin/kdenlive-appimage' /usr/share/applications/org.kde.kdenlive.desktop 2>/dev/null; then
  sudo rm -f /usr/share/applications/org.kde.kdenlive.desktop
fi
sudo rm -f /usr/share/applications/kdenlive-appimage.desktop /usr/local/share/applications/kdenlive-appimage.desktop
sudo rm -f /usr/share/icons/hicolor/{16x16,22x22,32x32,48x48,64x64,128x128,256x256,512x512,scalable}/apps/kdenlive-appimage.*
sudo update-desktop-database /usr/share/applications >/dev/null 2>&1 || true
sudo update-desktop-database /usr/local/share/applications >/dev/null 2>&1 || true
if command -v gtk-update-icon-cache >/dev/null 2>&1; then
  sudo gtk-update-icon-cache -q /usr/share/icons/hicolor >/dev/null 2>&1 || true
fi
hash -r
command -v kdenlive-appimage || echo "kdenlive-appimage removed"

Remove Flatpak Kdenlive on Ubuntu

Remove the system-scope Flatpak and its application data:

sudo flatpak remove --delete-data org.kde.kdenlive -y
flatpak list --system --app --columns=application | grep -Fx org.kde.kdenlive || echo "NOT_INSTALLED"

Remove Snap Kdenlive on Ubuntu

Remove the Kdenlive Snap without saving a recovery snapshot:

sudo snap remove --purge kdenlive
snap list kdenlive 2>/dev/null || echo "kdenlive not installed"

Troubleshoot Kdenlive on Ubuntu

Fix APT Cannot Locate Kdenlive

Kdenlive comes from Ubuntu’s Universe component. Minimal, server, cloud, or customized installs may not have that component enabled.

sudo apt install software-properties-common
sudo add-apt-repository universe
sudo apt update
apt-cache policy kdenlive

Fix Kdenlive AppImage Launch or Menu Icon Issues

If the AppImage downloads but does not start, or the application menu or dock shows a generic gear icon, recheck the FUSE package for your Ubuntu release and confirm the launcher, desktop entry, and icon file are present:

ls -l /opt/kdenlive-appimage/kdenlive.AppImage
dpkg-query -W -f='${binary:Package} ${db:Status-Abbrev}\n' libopengl0 libxcb-cursor0
grep -E '^(Name|Exec|Icon|StartupWMClass)=' /usr/share/applications/org.kde.kdenlive.desktop
ls -l /usr/share/icons/hicolor/scalable/apps/kdenlive-appimage.svg
kdenlive-appimage

On non-x86_64 systems, use Flatpak or Snap instead because KDE’s stable AppImage directory currently publishes the Linux AppImage for x86_64.

Avoid Mixed Kdenlive Install Methods

Multiple Kdenlive packages can coexist, but the desktop menu may show similar entries. If you are switching methods, remove the previous package source first, then install the new one so the launcher and update path stay clear.

Check Kdenlive Store Channels Before Switching

Flatpak and Snap metadata changes over time. Check the store record before switching channels, troubleshooting a missing version, or confirming that a store package has caught up with a current upstream security release:

flatpak remote-info flathub org.kde.kdenlive
snap info kdenlive

Conclusion

You now have several clean ways to install Kdenlive on Ubuntu. AppImage and Flatpak are the strongest choices when you want Kdenlive-team-supported Linux packages, Snap is available for users who prefer Snap refreshes, and APT remains the simple Ubuntu repository option. Keep the update and removal commands tied to the method you selected so future upgrades stay predictable.