Ubuntu 22.04 LTS Developer Workstation - Stop Fighting Your Desktop

Ubuntu 22.04 comes with GNOME 42, which looks nice in screenshots but will piss you off daily if you're actually trying to write code. The defaults are optimized for your grandmother checking email, not for someone running Docker containers and multiple IDEs.

Here's what breaks immediately after installation and how to fix it before you waste a week debugging random shit.

The GNOME 42 Problem - Wayland vs X11 Wars Continue

Ubuntu 22.04 defaults to Wayland instead of X11. Great in theory, still broken in practice for developers in 2025. Screen sharing doesn't work reliably, some electron apps have rendering issues, and good luck getting NVIDIA drivers to behave.

The fix that actually works: Switch back to X11 during login. Click the gear icon at bottom-right on the login screen, select "Ubuntu on Xorg". Your screen sharing works, OBS stops crashing, and development tools behave predictably.

For NVIDIA users: You're stuck with X11 anyway because Wayland on NVIDIA is still a disaster. The drivers work but expect random crashes when switching between virtual desktops or using external monitors.

Snap Packages Are Developer Cancer

Ubuntu forces Snap packages for Firefox, VS Code, and other developer tools. Snaps are slow, have weird filesystem isolation, and break when you need them most. Firefox takes 8 seconds to launch from a Snap vs 2 seconds from a .deb.

Nuclear option that works:

## Remove snap Firefox entirely
sudo snap remove firefox
sudo apt install firefox

## Remove snapd completely (scorched earth approach)
sudo systemctl stop snapd
sudo systemctl disable snapd
sudo apt purge snapd

Conservative approach (if you need some Snaps):

## Just install the .deb versions of critical tools
curl -fsSL https://code.visualstudio.com/sha/download?build=stable&os=linux-deb-x64 -o vscode.deb
sudo dpkg -i vscode.deb

Performance Tweaks That Actually Matter

The Medium article by Adarsh K covers this well, but here's what actually moves the needle:

Install preload - Preloads frequently used apps into RAM:

sudo apt install preload

Reduce swappiness - Prioritizes RAM over swap file:

echo "vm.swappiness=10" | sudo tee -a /etc/sysctl.conf

Enable ZRAM - Compresses memory instead of hitting disk:

sudo apt install zram-tools

These three changes make Ubuntu feel snappy instead of sluggish, especially if you're running multiple development environments.

Fix the Broken Package Management

Ubuntu 22.04's apt configuration is configured like it's still 2015. Enable parallel downloads and better caching:

## Create parallel download config
echo 'APT::Acquire::Retries "5";' | sudo tee /etc/apt/apt.conf.d/99parallel
echo 'Acquire::Queue-Mode "access";' | sudo tee -a /etc/apt/apt.conf.d/99parallel

Install essential dev tools from the Ubuntu development packages that should come with Ubuntu but don't:

sudo apt install curl wget git vim htop tree build-essential software-properties-common apt-transport-https ca-certificates gnupg lsb-release

The Python Version Hell Solution

Ubuntu 22.04 ships with Python 3.10, which is decent, but you'll need multiple Python versions for different projects. Don't fuck around with system Python. Use Python version management.

Install pyenv properly following the pyenv installation guide:

curl https://pyenv.run | bash

## Add to ~/.bashrc or ~/.zshrc
export PATH="$HOME/.pyenv/bin:$PATH"
eval "$(pyenv init --path)"
eval "$(pyenv virtualenv-init -)"

Now you can install any Python version without breaking your system or dealing with Ubuntu's weird package names like python3.10-dev.

Make Git Actually Usable

Ubuntu's default git config is useless. Set this up once:

git config --global user.name "Your Name"
git config --global user.email "your@email.com"
git config --global init.defaultBranch main
git config --global pull.rebase false
git config --global core.editor vim

Install the tools that make git bearable:

sudo apt install git-gui gitk meld

The reality: most developers who complain about Ubuntu 22.04 being "broken" never bothered fixing these basic configuration issues. Takes 20 minutes, saves you months of frustration.

Ubuntu desktop configured for development with VS Code, terminal access, file manager, and development tools visible in the dock and workspace.

You've fixed the basic system issues, now let's make it actually good for writing code. Here's how to set up a development environment that won't crash when you need to ship features.

Terminal Setup - Stop Using the Default

Ubuntu's default terminal is fine for checking logs, garbage for actual development work. Install a real terminal from the GNOME terminal alternatives list:

Option 1: Terminator (multiple panes, good for multitasking)

sudo apt install terminator

Option 2: Tilix (better GNOME integration)

sudo apt install tilix

Make it your default using update-alternatives:

sudo update-alternatives --config x-terminal-emulator

Shell Upgrade - Zsh + Oh My Zsh

Bash is fine, Zsh is better for development. The Oh My Zsh installation gives you better tab completion, git integration, and themes that don't look like 1995.

sudo apt install zsh
sh -c \"$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)\"

## Install [powerline fonts](https://github.com/powerline/fonts) for themes
git clone https://github.com/powerline/fonts.git --depth=1
cd fonts && ./install.sh && cd .. && rm -rf fonts

Set theme to 'agnoster' in ~/.zshrc:

ZSH_THEME=\"agnoster\"

Version Managers That Work

Don't install development languages through apt. Ubuntu's packages are always outdated and break when you need multiple versions.

Node.js - Use NVM:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
source ~/.bashrc
nvm install node
nvm install 18  # LTS version for production stuff

Python - Use pyenv (avoid Ubuntu's python3.10-dev bullshit):

curl https://pyenv.run | bash

## Add to ~/.zshrc
export PATH=\"$HOME/.pyenv/bin:$PATH\"
eval \"$(pyenv init --path)\"
eval \"$(pyenv virtualenv-init -)\"

pyenv install 3.11.8
pyenv install 3.10.13
pyenv global 3.11.8

Ruby - Use rbenv:

git clone https://github.com/rbenv/rbenv.git ~/.rbenv
echo 'export PATH=\"$HOME/.rbenv/bin:$PATH\"' >> ~/.zshrc
echo 'eval \"$(rbenv init -)\"' >> ~/.zshrc

## Install ruby-build plugin
git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build

rbenv install 3.2.0
rbenv global 3.2.0

Essential Development Tools

Git configuration that doesn't suck from the Git configuration guide:

git config --global init.defaultBranch main
git config --global pull.rebase false
git config --global push.autoSetupRemote true
git config --global core.editor code  # or vim if you're hardcore

Install build essentials (saves time when stuff needs compiling from Ubuntu development packages):

sudo apt install build-essential libssl-dev libffi-dev libxml2-dev libxslt1-dev libjpeg8-dev libpng-dev zlib1g-dev

Database tools for local development using Docker Compose for development environments:

## PostgreSQL client tools
sudo apt install postgresql-client-14

## MySQL client
sudo apt install mysql-client-core-8.0

## Redis CLI
sudo apt install redis-tools

## MongoDB tools
sudo apt install mongodb-clients

Docker Setup That Won't Break

Docker through Snap is broken. Install properly:

## Remove any existing Docker
sudo apt remove docker.io docker-doc docker-compose podman-docker containerd runc

## Add Docker's official GPG key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

## Add repository
echo \"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable\" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

## Install Docker Engine
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

## Add user to docker group (log out and back in after)
sudo usermod -aG docker $USER

Code Editor Wars - VSCode vs JetBrains

VSCode (free, lightweight, good for most languages):

wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -o root -g root -m 644 packages.microsoft.gpg /etc/apt/trusted.gpg.d/
sudo sh -c 'echo \"deb [arch=amd64,arm64,armhf signed-by=/etc/apt/trusted.gpg.d/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main\" > /etc/apt/sources.list.d/vscode.list'
sudo apt update
sudo apt install code

Essential VSCode extensions:

• GitLens
• Prettier
• ESLint
• Python
• Docker
• Remote - SSH

JetBrains IDEs (paid, heavyweight, excellent for specific languages):

## Install JetBrains Toolbox for easy management
wget -O jetbrains-toolbox.tar.gz \"https://data.services.jetbrains.com/products/download?platform=linux&code=TBA\"
tar -xzf jetbrains-toolbox.tar.gz
./jetbrains-toolbox-*/jetbrains-toolbox

Performance Monitoring Tools

Install htop and friends:

sudo apt install htop iotop nethogs ncdu tree

• htop - Better top with colors and mouse support
• iotop - Shows which processes are hitting disk I/O hard
• nethogs - Network usage by process
• ncdu - Disk usage analyzer
• tree - Show directory structure

For system monitoring:

sudo apt install gnome-system-monitor psensor

SSH Key Management

Generate proper SSH keys:

ssh-keygen -t ed25519 -C \"your_email@example.com\"
eval \"$(ssh-agent -s)\"
ssh-add ~/.ssh/id_ed25519

Add to GitHub/GitLab:

cat ~/.ssh/id_ed25519.pub
## Copy output and add to your Git provider's SSH keys

File Manager That Doesn't Suck

Nautilus (Files) is basic. Install something better:

## Thunar (lightweight, fast)
sudo apt install thunar

## Dolphin (feature-rich, good for power users)
sudo apt install dolphin

Both support tabs, better search, and don't crash when copying large files.

The Database Development Setup

For local database testing:

## Install Docker Compose configs for common databases
mkdir -p ~/dev/docker-databases
cd ~/dev/docker-databases

## PostgreSQL
cat > docker-compose.postgres.yml << EOF
version: '3.8'
services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: devdb
      POSTGRES_USER: dev
      POSTGRES_PASSWORD: dev123
    ports:
      - \"5432:5432\"
    volumes:
      - postgres_data:/var/lib/postgresql/data
volumes:
  postgres_data:
EOF

## MySQL
cat > docker-compose.mysql.yml << EOF
version: '3.8'
services:
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: root123
      MYSQL_DATABASE: devdb
      MYSQL_USER: dev
      MYSQL_PASSWORD: dev123
    ports:
      - \"3306:3306\"
    volumes:
      - mysql_data:/var/lib/mysql
volumes:
  mysql_data:
EOF

## Redis
cat > docker-compose.redis.yml << EOF
version: '3.8'
services:
  redis:
    image: redis:7
    ports:
      - \"6379:6379\"
EOF

Start any database:

docker compose -f docker-compose.postgres.yml up -d

Now you have proper development databases without polluting your system with a bunch of database servers.

Reality check: This setup takes about 2 hours to complete properly, but saves you weeks of fighting broken tools later. Most developers skip this setup phase and then wonder why their environment is constantly breaking.