If you used ChatGPT Atlas and you’re on Linux, the ChatGPT desktop app is what you install now. OpenAI retired Atlas (its release notes set August 9, 2026 as the day it stopped working) and moved the browser features into one desktop app that holds Chat, Codex and a built-in browser. The same app is now available on Linux as a preview, with official .deb and .rpm packages and an install script for Arch, so you get a real native app instead of a browser tab or an unofficial wrapper.
This guide covers installing the ChatGPT desktop app on Ubuntu 26.04 and 24.04 and Fedora 44 and 43, with a note on OpenAI’s Arch script. You’ll also get the chatgpt command, sign-in, updates, Wayland versus X11, what Linux can’t do yet, and a clean uninstall. I ran it all in November 2026 against ChatGPT 26.1106.51428. The app reached its sign-in screen in a sway Wayland session on Ubuntu 26.04 and Fedora 44 VMs, and under a plain X server on an Ubuntu 24.04 VM. The Fedora 43 and Arch installs ran in clean containers, so those two were checked for install only.
Understand what replaced ChatGPT Atlas
There is no ChatGPT Atlas to install on Linux in 2026, and there won’t be. OpenAI’s Atlas retirement notice says Atlas has been retired and no longer gets updates, and its July 9 release note moved Atlas’s browser agent features into ChatGPT and Codex. So if you searched for “ChatGPT Atlas Linux”, the app in this guide is the closest thing you’ll get, and it is the one OpenAI actually supports.
Atlas data didn’t move across by itself. Before the shutdown you could export cookies and passwords into the ChatGPT desktop app and bookmarks to Chrome, while open tabs and history had no export path at all, and the help article says recovery after the fact isn’t guaranteed. Your ChatGPT conversations are a different matter: OpenAI says they stay available in ChatGPT, so signing in to the desktop app with the same ChatGPT account should bring them back (the lab had no account to confirm it). If you want a regular browser to sit next to it, our browser benchmarks for Linux and Windows compare the main options.
Check your distro and processor first
The preview officially supports desktop installs of Ubuntu 24.04 and 26.04, Debian 13, Fedora 43 and 44, and a fully updated Arch Linux, each on x64 and ARM64. Other distributions may work, but OpenAI doesn’t support them, so you’re on your own if something breaks. Each one gets the app a different way:
| Distro | Package | Install with | Repo it adds | Tested here |
|---|---|---|---|---|
| Ubuntu 26.04 / 24.04 | chatgpt_amd64.deb or chatgpt_arm64.deb | apt | /etc/apt/sources.list.d/chatgpt.sources | Yes, x64 VM |
| Debian 13 | same .deb | apt | same file | No |
| Fedora 44 / 43 | chatgpt.x86_64.rpm or chatgpt.aarch64.rpm | dnf | /etc/yum.repos.d/chatgpt.repo | Yes, x64 VM (44), container (43) |
| Arch Linux | chatgpt-bin via install-arch.sh | pacman | /etc/pacman.d/openai-chatgpt.conf | Install only, x64 container |
Before you download anything, check which architecture you’re on, because the package names differ and picking the wrong one just fails to install:
uname -m
A result of x86_64 means you want the x64 package, and aarch64 or arm64 means ARM64. Then run through this short checklist:
- You’re signed in to a graphical desktop session, not only an SSH shell.
- You have about 2.5 GB of free disk for the app and its dependencies.
- Your user can run
sudo. - You have a ChatGPT account to sign in with (an OpenAI API key or Amazon Bedrock also works, but only for local Codex work).
The disk figure is real, not padding: on a server image Ubuntu needed 2235 MB for the app plus 176 dependencies, and pacman reported 2428 MiB installed on Arch. A normal desktop already has most of the GTK and audio libraries, so you’ll usually need less than that.
Install ChatGPT on Ubuntu 26.04 or 24.04
On Ubuntu you install a single .deb, and its install script adds OpenAI’s signed apt repository for you, so later updates arrive with your normal system updates. You can grab the package from the download links on the official Linux install page, or pull the latest x64 build straight into your Downloads folder:
cd ~/Downloads
wget https://persistent.oaistatic.com/codex-app-prod/linux/deb/latest/chatgpt_amd64.deb
On an ARM64 machine, swap chatgpt_amd64.deb for chatgpt_arm64.deb in the URL. The file is large (538 MB for the x64 build), so give it a minute. Now install it with apt, keeping the ./ in front so apt treats it as a local file rather than a package name:
sudo apt install ./chatgpt_amd64.deb
Once it finishes, ask the new chatgpt command for its version. If you see a version string like the one below, the app is installed and the launcher is on your PATH:
chatgpt --version
This excerpt of the run on the Ubuntu 26.04 VM keeps the lines that matter, from the architecture check to the version:

The Ubuntu 24.04 VM gave the same result with no changes to the commands. That’s worth knowing, because the package depends on libssl3 and 24.04 renamed it to libssl3t64, but the new package still provides the old name, so apt resolves it without complaint. If you’re on Debian 13, OpenAI lists it as supported with the same .deb and the same two commands, though it wasn’t part of this lab.
The install also drops three files you should know about, because they explain how updates and the sandbox work later:
- You get an apt source at
/etc/apt/sources.list.d/chatgpt.sourcesthat points at OpenAI’s repository. - You get the signing key at
/usr/share/keyrings/chatgpt-archive-keyring.gpg. - You get an AppArmor profile at
/etc/apparmor.d/chatgptthat lets the app’s sandbox use user namespaces.
Right after the install, apt policy chatgpt only lists the local dpkg entry, which looks as if the repository didn’t take. It did. apt just hasn’t downloaded the new repository’s index yet, so run sudo apt update once and check again:
sudo apt update
apt policy chatgpt
Now the OpenAI repository shows up with priority 500, which means future versions will come from there:

If you’d rather not have a third-party repository at all, delete chatgpt.sources. The package keeps a repo_add_once="false" flag in /etc/default/chatgpt, and in the lab the file stayed gone after a delete and a reinstall of the .deb. You’d then update by downloading a fresh .deb yourself.
Install the ChatGPT app on Fedora 44 or 43
The ChatGPT app Fedora users get is an .rpm, and it works the same way: you install the local file with dnf, and the package writes a repo file so dnf upgrade picks up new builds. Download the x64 package (use chatgpt.aarch64.rpm on ARM64):
cd ~/Downloads
wget https://persistent.oaistatic.com/codex-app-prod/linux/rpm/latest/chatgpt.x86_64.rpm
Install it with the leading ./, the same as on Ubuntu:
sudo dnf install ./chatgpt.x86_64.rpm
Near the end dnf prints Warning: skipped OpenPGP checks for 1 package from repository: @commandline. If you see that, it’s normal: dnf doesn’t check the signature of a file you hand it directly, only packages that come from a repository. The OpenAI key gets imported the first time dnf talks to the new repo, so run a refresh straight away to get that out of the way:
sudo dnf upgrade --refresh chatgpt
You’ll be shown the key fingerprint 3BFA0E4AE8B8CC16A2D9BA684A3B4A566C4660E4 and a “The key was successfully imported” line, then “Nothing to do” because you already have the newest build. That’s the same fingerprint the Arch script checks, so all three formats are signed by one OpenAI key. Here is the whole sequence on a Fedora 44 VM running a sway Wayland session with XWayland, where the only extra packages dnf wanted were git and the Perl modules it depends on:

Sixty-eight packages and 2 GiB of disk is what it came to, most of that the app itself. Fedora Workstation with GNOME ships a different package set, so your count will differ a little. The same steps ran in clean fedora:44 and fedora:43 containers too, where dnf pulled 395 and 397 packages because a container has none of the desktop libraries, and the key import was identical on both. Starting chatgpt in the Fedora 44 sway session opened the same sign-in window as on Ubuntu:

That window is an XWayland one, which the Wayland section below explains. If you’ve just set the machine up, our Fedora 44 post-install checklist covers the RPM Fusion and codec steps that are worth doing before you add third-party apps like this one. Anthropic’s app has no official Fedora package yet, so if you want Claude next to the ChatGPT desktop app on Linux, our guide to Claude Desktop on Linux covers the unofficial Fedora routes.
Use OpenAI’s install script on Arch Linux
OpenAI supports a fully updated Arch, but Arch gets less coverage in this guide than Ubuntu and Fedora. I ran the script in a clean archlinux container, which proves the install and the signing checks but not how the app behaves on an Arch desktop. Arch doesn’t get a package file to download. OpenAI publishes a script that verifies its signing key against a pinned fingerprint, adds a signed [openai-chatgpt] pacman repository and installs chatgpt-bin. The part that trips people up is that it runs a full pacman -Syu, so it updates your whole system along the way. Do it when you’re happy to take a full upgrade, not in the middle of something else:
curl --proto '=https' --tlsv1.2 -fL -o install-arch.sh \
https://persistent.oaistatic.com/codex-app-prod/linux/install-arch.sh
sudo bash install-arch.sh
You’ll see two “Good signature” lines from gpg, then the usual pacman summary and a Proceed with installation? [Y/n] prompt. The “[unknown]” trust note on the gpg lines isn’t a problem, because the script checks the fingerprint itself before it imports anything and refuses to continue if it doesn’t match:

On a stripped-down Arch base the package’s install hook printed cmp: command not found twice, because cmp comes from diffutils and that isn’t in every base install. The app still installed and chatgpt --version answered normally. Installing diffutils first made the warning go away on the next clean run, so do that if your system is minimal:
sudo pacman -S --needed diffutils
Arch is the only format where chatgpt isn’t the package name: the package is chatgpt-bin, and it provides chatgpt. Keep that in mind when you query or remove it with pacman later.
Launch the ChatGPT desktop app and sign in
Open ChatGPT from your applications menu, or type chatgpt in a terminal inside your desktop session. The command is a small launcher script at /usr/lib/chatgpt/codex-launcher that starts the real binary and passes along any flags you give it, which is how the Wayland flag later in this guide reaches the app. The first window is the sign-in screen:

- 1Continue to sign in
- 2Sign in another way
You have two ways in, and most people want the first one:
- Click Continue to sign in to log in with your ChatGPT account in your web browser.
- Click Sign in another way if you want to use an OpenAI API key or Amazon Bedrock instead of a ChatGPT plan.
The second path is easy to miss, and it’s narrower than it looks. OpenAI’s authentication docs say an API key covers local Codex workflows billed at API rates, while features that rely on ChatGPT workspace access or cloud services are limited or unavailable. It opens this screen:

- 1OpenAI API Key
- 2Use Amazon Bedrock
Pick OpenAI API Key if you only want Codex on local projects and bill it to your API account, or Use Amazon Bedrock if your models come through AWS. For Chat and the rest of the app, use your ChatGPT account. Click Back to return to the main screen. When you choose Continue to sign in, the app hands a login link to your default browser and waits:

If no browser window appears, click Copy sign-in link and paste it into any browser yourself. That happened in the lab. The package registers ChatGPT as a handler for http and https links, and on a machine with no other browser registered, xdg-mime query default x-scheme-handler/https returned chatgpt.desktop. The login link went straight back into the app, the log printed “Opening in existing browser session.” and nothing visible happened. Once Firefox was the default handler for web links, the same button opened the OpenAI login page:

Log in there with email, Google, Apple, Microsoft or phone, and the browser sends you back to the app through a codex:// link that the package also registers. The lab had no ChatGPT account to sign in with, so the walkthrough stops at this page and the screens after login aren’t shown here. If Firefox or another browser is already your default for web links, the button should open it directly; the loop happens when no other browser has claimed them.
Run ChatGPT on Wayland or X11
On a Wayland desktop, which is the only GNOME session on Ubuntu 26.04 and Fedora 44 and 43, the app runs through XWayland unless you ask for native Wayland. OpenAI calls native Wayland support experimental and warns that floating windows, window positioning, focus and keyboard shortcuts may not fully work yet. Both modes were tested only in a sway Wayland session at 200% scaling, not under GNOME, because sway reports how each window connects. A plain chatgpt launch came up as an xwayland window, and the forced native launch came up as xdg_shell, which confirms the default really is XWayland.
To try native Wayland, quit the app completely first, because closing the window isn’t always enough. This shows any ChatGPT process still running and stops it:
pgrep -xa ChatGPT
pkill -x ChatGPT
Then start it from a terminal with the Ozone flag:
chatgpt --ozone-platform=wayland
Native mode came up fine at first glance, then showed the bug OpenAI warns about. The page drew at roughly 80% of the window width and left a black strip down the right side, and it stayed that way for over a minute:

Resizing the window once (in sway, toggling it to floating and back) made the page fill the window properly. The Fedora 44 VM reproduced it exactly: a plain launch was an xwayland window that filled its frame, and the --ozone-platform=wayland launch was an xdg_shell window with the same black strip on the right. That fits OpenAI’s warning about window sizing, and it’s why the default XWayland mode is the better pick for daily use. Switch only if XWayland gives you trouble, such as blurry text on a fractionally scaled screen. The terminal also showed drmGetDevices2() has not found any devices in native mode, which only means the VM had no GPU render node; the app fell back to software rendering and kept running.
If native Wayland works well on your machine and you want it every time, give yourself a user copy of the launcher with the flag added. A file in ~/.local/share/applications overrides the system one and survives package updates:
mkdir -p ~/.local/share/applications
cp /usr/share/applications/chatgpt.desktop ~/.local/share/applications/
sed -i 's|^Exec=chatgpt %U|Exec=chatgpt --ozone-platform=wayland %U|' ~/.local/share/applications/chatgpt.desktop
Launching from the menu after that started /usr/lib/chatgpt/ChatGPT --ozone-platform=wayland as an xdg_shell window in the test. To go back to XWayland, delete ~/.local/share/applications/chatgpt.desktop. On an X11 session (“Ubuntu on Xorg” on 24.04, or Xfce, MATE and Cinnamon on any distro) you don’t need any of this, because X11 is what the app uses anyway.
Update the ChatGPT app
Updates come through the repository each package added, so you do not need to download new installers. Use the command for your distro:
| Distro | Update command | Result on the current build |
|---|---|---|
| Ubuntu / Debian | sudo apt update && sudo apt install --only-upgrade chatgpt | chatgpt is already the newest version |
| Fedora | sudo dnf upgrade --refresh chatgpt | Nothing to do |
| Arch Linux | sudo pacman -Syu | there is nothing to do |
On Ubuntu and Fedora a regular full upgrade (sudo apt upgrade or sudo dnf upgrade) catches ChatGPT too, so if you already update your system weekly you don’t have to do anything extra. On Arch, OpenAI wants you to update the app as part of a full system upgrade rather than on its own, which is the normal Arch rule against partial upgrades anyway.
Know what works on Linux and what doesn’t
The ChatGPT desktop app Linux preview has the core of the app, but it isn’t feature-matched with macOS and Windows yet. The biggest gap is Computer Use, the feature that lets ChatGPT see and operate other desktop applications: OpenAI’s Computer Use page lists macOS and Windows only, and the Linux release note says controlling other desktop apps isn’t supported yet. Browser actions are a different thing and they do work, either in the built-in browser or in Chrome. OpenAI’s Linux note names Chat and Codex; whether Work shows up depends on your plan and workspace, as it does on the other platforms.
| Feature | Linux preview | macOS / Windows |
|---|---|---|
| Chat and Codex in one app | Yes | Yes |
| Built-in browser and browser actions | Yes | Yes |
| Working in Chrome | Yes | Yes |
| Computer Use (control other apps) | Not yet | Yes |
| Native display server | X11, or XWayland on Wayland; native Wayland experimental | Native |
Codex inside the desktop app keeps its config in ~/.codex, the same folder the Codex CLI uses. If you mostly live in the terminal, the Codex CLI cheat sheet covers the commands, and our comparison of OpenCode, Claude Code, Cursor and Codex CLI helps if you’re still choosing a coding agent. If you want an editor next to the app, you can also install VS Code on Ubuntu 26.04.
Fix common ChatGPT errors on Linux
Every error below came up in the lab, word for word. Each one points at a different cause, so match the exact message before you try a fix.
Error: “Missing X server or $DISPLAY”
You ran chatgpt from a shell that isn’t attached to a desktop, usually an SSH session or a TTY. The app exits with “The platform failed to initialize”. Start it from a terminal inside your graphical session or from the applications menu. chatgpt --version is the one command that works without a display, which makes it handy for checking an install over SSH.
Error: “No usable sandbox!”
Ubuntu 23.10 and later block unprivileged user namespaces through AppArmor, and Chromium-based apps need them for their sandbox. The ChatGPT package ships an AppArmor profile that allows it, so you only hit this when the profile isn’t loaded, for example after someone ran apparmor_parser -R on it or disabled it. Unloading it on purpose reproduces the crash:

Reload the profile and the app starts normally again. Don’t reach for --no-sandbox here, because that turns off a security layer to work around a missing file:
sudo apparmor_parser -r /etc/apparmor.d/chatgpt
sudo aa-status | grep chatgpt
If /etc/apparmor.d/chatgpt is gone altogether, a plain apt install --reinstall won’t bring it back, because dpkg treats a deleted config file as your choice. In the lab the file stayed missing after one. Tell dpkg to restore missing config files instead:
sudo dpkg -i --force-confmiss ~/Downloads/chatgpt_amd64.deb
dpkg answers with “Configuration file ‘/etc/apparmor.d/chatgpt’, does not exist on system. Installing new config file as you requested.” and the profile is back. Run the apparmor_parser -r command above once more to be sure it’s loaded.
Error: “Running as root without –no-sandbox is not supported”
You started the app with sudo chatgpt or from a root shell. It is a desktop app for your own user, and nothing in it needs root, so run plain chatgpt as your normal account.
Sign-in link opens nothing or reopens ChatGPT
Your system has no other browser registered for web links, so the link goes back into ChatGPT, which registers itself for http and https. Set a real browser as the default in your desktop’s default-apps settings, or from a terminal with your browser’s desktop file name. On Ubuntu with the Firefox snap that’s:
xdg-mime default firefox_firefox.desktop x-scheme-handler/http x-scheme-handler/https
For another browser, use its file name from /usr/share/applications (or /var/lib/snapd/desktop/applications for snaps). If you can’t change the default right now, use Copy sign-in link on the waiting screen and paste the link into a browser by hand.
Uninstall ChatGPT from Linux
Removing the package is quick, but each package manager leaves a different amount behind, and your user data stays put on all three. On Ubuntu and Debian, use purge rather than remove:
sudo apt purge chatgpt
The difference shows up right away. A plain apt remove deleted the app but left chatgpt.sources, the keyring and the AppArmor profile in place, so apt kept polling OpenAI’s repository. purge removed all three. Fedora is simpler, since sudo dnf remove chatgpt took /etc/yum.repos.d/chatgpt.repo away with the package in both containers.
Arch leaves the most behind. After pacman -Rns chatgpt-bin the repository file, its Include line in /etc/pacman.conf and the OpenAI key in pacman’s keyring were all still there. These commands clean them up, and a pacman -Syu afterwards ran without the OpenAI repo:
sudo pacman -Rns chatgpt-bin
sudo rm /etc/pacman.d/openai-chatgpt.conf
sudo sed -i '\|^Include = /etc/pacman.d/openai-chatgpt.conf$|d' /etc/pacman.conf
sudo pacman-key --delete 4A3B4A566C4660E4
Your own files are the part people forget, and they are bigger than the app itself. After a short session the lab user had these folders, none of which any package manager touches:
- There’s about 1.7 GB in
~/.cache/codex-runtimes, the runtime the app downloads on first launch. - There’s about 150 MB of app settings and browser data in
~/.config/Codex. - There’s a small cache in
~/.cache/Codex. - There’s about 110 MB in
~/.codex, which holds Codex config, logs and memories.
Delete the first three to get your disk space back:
rm -rf ~/.config/Codex ~/.cache/Codex ~/.cache/codex-runtimes
Leave ~/.codex alone if you also use the Codex CLI, because the CLI reads the same folder and you’d lose its config and history. If the desktop app was your only Codex tool, you can delete that folder too, and your ChatGPT conversations stay safe in your account either way.