Anyone who has spun up a fresh Ubuntu 24.04 LTS install and typed sudo apt install telegram expecting it to just work has probably run into a wall of confusing package names, PPA warnings, or a GUI app that silently fails to launch after installation. It sounds like it should be trivial — Telegram is one of the most widely used messaging platforms on the planet, with over 900 million monthly active users — yet Ubuntu doesn’t ship it as a default package, and the installation landscape has shifted multiple times over the past few release cycles.

Part of the confusion comes from the fact that there isn’t just one “correct” way to install Telegram on Ubuntu. Depending on whether you’re managing a personal workstation, a shared terminal server, or a minimal headless box you SSH into for automation tasks, the right method changes. A desktop user running GNOME on a laptop has completely different needs than a sysadmin who wants Telegram notifications wired into a monitoring pipeline on a jump box.

This guide walks through every practical installation method available on Ubuntu 24.04 Noble Numbat — APT via the universe repository, the community PPA, Snap, Flatpak, and the official standalone binary from Telegram’s own servers — along with the tradeoffs of each. It also covers the parts most tutorials skip entirely: sandboxing implications, notification daemon conflicts, firewall considerations for corporate networks, and what to do when the app installs cleanly but refuses to open. If you’ve been burned before by a broken snap package or a PPA that hasn’t been updated in two years, this should clear things up.

By the end, you’ll know not just how to get Telegram running, but which method actually fits your environment — and why that decision matters more than most guides let on.

System Requirements and Pre-Checks

Ubuntu 24.04 LTS is built on the Linux 6.8 kernel and ships with GNOME 46 by default, though plenty of admins run it headless or with alternative desktop environments like XFCE or KDE Plasma. Telegram Desktop itself is lightweight — it’ll run comfortably on 2GB of RAM and barely touches CPU when idle — but a few pre-checks save headaches later.

First, confirm your Ubuntu version and architecture:

lsb_release -a
uname -m

Telegram Desktop officially supports x86_64 and, more recently, arm64 builds, which matters if you’re deploying on Raspberry Pi hardware or ARM-based cloud instances. If you’re on an unsupported architecture, the Flatpak and Snap routes tend to be more forgiving than the raw tarball.

Second, make sure your package index isn’t stale:

sudo apt update && sudo apt upgrade -y

Skipping this step is one of the most common reasons installations fail halfway through — dependency resolution breaks when the local package cache is out of sync with upstream repositories, especially right after a fresh Ubuntu install where the cache hasn’t been touched yet.

Method 1: Installing Telegram via APT (Recommended for Most Users)

Since Ubuntu 22.04, Canonical’s universe repository has carried a native telegram-desktop package, and that continues into 24.04. This is genuinely the cleanest method for most desktop users because it integrates with your existing package manager, respects system theming, and gets security patches through the normal apt upgrade cycle rather than requiring a separate update mechanism.

Step-by-Step APT Installation

Enable the universe repository if it isn’t already active — most desktop installs have it on by default, but minimal server images often don’t:

sudo add-apt-repository universe
sudo apt update

Now install the package:

sudo apt install telegram-desktop -y

Verify the install and check the version:

telegram-desktop --version

Launch it from the terminal directly, or find it under Activities → Show Applications if you’re on GNOME.

Why This Method Works Well in Practice

The Ubuntu-packaged version of Telegram lags slightly behind the absolute latest upstream release — usually by a few weeks to a couple of months — because it goes through Debian/Ubuntu’s packaging and QA pipeline before landing in universe. For most users, that delay is a non-issue and arguably a feature: you get a build that’s been vetted rather than bleeding-edge. If you need day-one access to new Telegram features (custom themes, newly released Premium features, etc.), this isn’t your method. For everyone else, it’s the path of least resistance.

One caveat worth mentioning from experience: on systems where universe was manually disabled for compliance reasons (common in hardened enterprise images), this install will fail with an “Unable to locate package” error. Check your sources first before assuming something’s broken with your mirror.

Method 2: Installing via the Community PPA

If you want a build that tracks upstream more closely than the universe package, the long-standing atareao PPA (and its successor maintained under costamagnagianfranco) has been a trusted source in the Ubuntu community for years.

sudo add-apt-repository ppa:atareao/telegram
sudo apt update
sudo apt install telegram -y

Note the package name here is telegram, not telegram-desktop — a small but common source of confusion when people copy-paste commands between tutorials without checking which repo they’ve added.

When a PPA Makes Sense — and When It Doesn’t

PPAs are convenient, but they come with a real tradeoff: you’re trusting a third-party maintainer with root-level package installation rights on your system, since PPA packages install with the same privileges as anything from the official Ubuntu archive. On a personal laptop, that’s usually an acceptable risk given the PPA’s long track record. On a production server or any machine handling sensitive data, it’s harder to justify — auditability matters, and PPAs don’t go through Canonical’s review process.

If you do add a PPA, get in the habit of removing it if you switch to another installation method later, otherwise you end up with duplicate or conflicting package sources:

sudo add-apt-repository --remove ppa:atareao/telegram

Method 3: Installing via Snap (Best for Isolation and Auto-Updates)

Snap comes preinstalled on standard Ubuntu 24.04 desktop images, which makes this arguably the fastest single-command install:

sudo snap install telegram-desktop

That’s genuinely the entire installation. Snap handles dependency bundling internally, so there’s no risk of library version conflicts with the rest of your system — a real problem on systems running older or customized library stacks.

The Sandboxing Tradeoff

Snap packages run inside a confined sandbox using AppArmor profiles, which is a legitimate security advantage: if Telegram Desktop ever had a vulnerability exploited in the wild, the blast radius is contained by the snap’s confinement rules. The downside shows up in day-to-day usability. File picker dialogs sometimes can’t see your full home directory by default, and integrations with certain desktop notification systems can behave inconsistently depending on your desktop environment.

To grant Telegram broader filesystem access when the sandbox is too restrictive (a common complaint when trying to send files from mounted network drives):

sudo snap connect telegram-desktop:removable-media

Snap also auto-updates in the background by default, which is great for staying patched but can be disruptive if you’re mid-conversation and the app suddenly restarts. You can check pending updates or force a refresh manually:

snap refresh telegram-desktop

Method 4: Installing via Flatpak (Best Cross-Distro Consistency)

Flatpak isn’t installed by default on stock Ubuntu, so there’s an extra setup step, but it’s popular among users who run multiple distros and want identical app behavior across all of them.

sudo apt install flatpak -y
sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
sudo flatpak install flathub org.telegram.desktop -y

Launch it with:

flatpak run org.telegram.desktop

If you’re on GNOME, installing the GNOME Software Flatpak plugin makes future Flatpak apps discoverable through the normal Software Center GUI:

sudo apt install gnome-software-plugin-flatpak

Flatpak’s sandboxing model is conceptually similar to Snap’s but tends to play slightly nicer with desktop integrations like drag-and-drop and system tray icons in my experience, particularly on non-GNOME desktop environments like KDE or Cinnamon.

Method 5: Installing the Official Binary (Maximum Control)

For anyone who wants zero dependency on a third-party repo, snap store, or flathub — say, an air-gapped environment or a strict compliance setup — downloading Telegram’s official tarball directly and running it standalone is the most transparent method.

cd ~/Downloads
wget https://telegram.org/dl/desktop/linux -O tsetup.tar.xz
tar -xf tsetup.tar.xz
sudo mv Telegram /opt/Telegram
sudo ln -sf /opt/Telegram/Telegram /usr/local/bin/telegram-desktop

Launch it:

telegram-desktop

Creating a Proper Desktop Entry

Running it from /opt works fine from the terminal, but without a .desktop file it won’t show up in your application launcher, which annoys users who expect a normal icon-click experience. Create one manually:

sudo nano /usr/share/applications/telegram-desktop.desktop

Paste:

[Desktop Entry]
Name=Telegram Desktop
Comment=Official Telegram Desktop Client
Exec=/opt/Telegram/Telegram -- %u
Icon=/opt/Telegram/telegram.png
Terminal=false
Type=Application
Categories=Network;InstantMessaging;

Refresh the desktop database so GNOME picks it up immediately:

sudo update-desktop-database

This method also makes updates fully manual — Telegram won’t auto-update itself here, so you’ll periodically need to repeat the download-and-swap process, which is a real maintenance burden on systems you don’t log into often.

Choosing the Right Method for Your Use Case

If you’re managing this on a single personal machine, Snap or APT covers 90% of real-world needs with the least friction. If you’re deploying across a fleet of workstations via configuration management (Ansible, Puppet, whatever your shop uses), the tarball method is often easier to script and pin to a specific version — Snap and Flatpak’s auto-update behavior makes version pinning across a fleet more annoying than it should be.

Troubleshooting Common Installation Issues

“Unable to locate package telegram-desktop”

This almost always means the universe repository isn’t enabled, or your package index is stale. Run:

sudo add-apt-repository universe
sudo apt update

If it still fails, check /etc/apt/sources.list and /etc/apt/sources.list.d/ for any malformed or duplicate entries that might be blocking index refresh.

Snap Package Installs But Won’t Launch

This usually traces back to snapd itself being outdated or the snap daemon socket not running correctly, especially on systems where snapd was recently reinstalled:

sudo systemctl status snapd
sudo systemctl restart snapd

If Telegram launches but crashes immediately with a segfault, check for conflicting Mesa/graphics driver issues — this is a known pain point on systems with proprietary NVIDIA drivers and older Snap runtime revisions. Forcing software rendering as a diagnostic step:

LIBGL_ALWAYS_SOFTWARE=1 telegram-desktop

If that launches cleanly, you’re dealing with a GPU driver compatibility issue, not a Telegram problem.

Notifications Not Appearing

Both Snap and Flatpak builds run sandboxed, which sometimes blocks access to the system notification daemon (org.freedesktop.Notifications). For Flatpak:

flatpak override --user --talk-name=org.freedesktop.Notifications org.telegram.desktop

GPG Key Errors When Adding the PPA

If add-apt-repository throws a GPG signature error, it’s typically a keyserver timeout rather than an actual security problem. Retry with an explicit keyserver:

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys <KEY_ID>

Note that apt-key is deprecated as of newer Ubuntu releases — for a cleaner long-term fix, import keys into /etc/apt/trusted.gpg.d/ directly rather than relying on the legacy keyring.

Telegram Freezes on Startup After a System Update

This is a known behavior after major library updates (particularly libgtk or Qt updates) when running the tarball version, since it bundles its own libraries and can conflict with newer system-level shared libraries. Deleting the local cache often resolves it:

rm -rf ~/.local/share/TelegramDesktop/tdata/cache

Security and Performance Considerations for Production Environments

If Telegram is going onto a machine that also runs production workloads — a jump host, a monitoring dashboard box, anything internet-facing — treat it like any other third-party application with network access, not a trivial convenience install.

Firewall rules: Telegram uses ports 443 and 80 for standard connections, plus a range of UDP ports for its MTProto protocol when possible. On servers running ufw, you generally don’t need custom rules since outbound traffic is typically allowed by default, but if you’re running a restrictive egress policy (common in hardened environments), you’ll need to explicitly permit outbound HTTPS:

sudo ufw allow out 443/tcp
sudo ufw allow out 80/tcp

Avoid running GUI messaging apps as root. It sounds obvious, but on minimal server setups where people log in directly as root out of habit, this is genuinely common. Create a dedicated non-privileged user for any interactive desktop application:

sudo adduser telegramuser

Sandboxed formats reduce blast radius. For anything internet-facing or shared among multiple users, Snap or Flatpak’s confinement is a meaningful security layer over the raw tarball — a compromised Telegram process can’t as easily pivot to reading arbitrary files outside its granted permissions.

Resource footprint is minor but not zero. Telegram Desktop typically sits around 150–300MB of RAM idle, spiking during video calls or large file transfers. On resource-constrained VPS instances running other services, monitor with:

systemctl status
htop

If you notice sustained high CPU from the Telegram process specifically, it’s often tied to background sync of large chat histories or heavy sticker pack caching — clearing the cache directory mentioned above usually resolves it.