How To Install Development Tools on Ubuntu 24.04 LTS

Ubuntu 24.04 LTS (Noble Numbat) represents a milestone for software developers seeking a stable, secure, and feature-rich platform. This Long-Term Support release provides five years of continuous updates, making it an ideal foundation for programming projects. Setting up a complete development environment requires installing essential compilers, build tools, version control systems, programming language frameworks, and integrated development environments. Whether you’re building web applications, system software, mobile apps, or data science projects, having the right toolkit transforms your Ubuntu system into a powerful coding workstation. This comprehensive guide walks you through installing every critical development tool on Ubuntu 24.04 LTS, from foundational packages to specialized software, ensuring you’re ready to write, compile, debug, and deploy code efficiently.

Prerequisites and System Requirements

Ubuntu 24.04 LTS demands specific hardware capabilities to deliver optimal development performance. The minimum configuration includes a 2 GHz dual-core processor, 4 GB RAM, 25 GB available storage, and VGA display supporting 1024×768 resolution. However, smooth development workflows benefit significantly from enhanced specifications. A quad-core processor handles compilation tasks faster. Eight gigabytes of RAM prevents slowdowns when running multiple tools simultaneously. Allocating 50 GB or more storage accommodates project files, dependencies, and virtual environments.

Administrative access through sudo privileges is mandatory for system-level package installations. Verify your account has these permissions before proceeding. Stable internet connectivity enables downloading packages from Ubuntu repositories and third-party sources. While basic terminal familiarity helps, this guide provides explicit commands suitable for beginners. Check your current Ubuntu version by opening Terminal and executing lsb_release -a to confirm you’re running 24.04 LTS before continuing with installations.

Preparing Your Ubuntu 24.04 System

System preparation establishes a clean foundation for development tool installations. Updating existing packages prevents compatibility conflicts and patches security vulnerabilities. Package managers maintain databases of available software versions. Refreshing these databases ensures you install the latest stable releases.

Open Terminal using Ctrl+Alt+T keyboard shortcut. Execute the following command to update package lists and upgrade installed software:

sudo apt update && sudo apt upgrade -y

The apt update component synchronizes package indexes with Ubuntu repositories, downloading information about newest versions. The apt upgrade portion installs updated versions of currently installed packages. The double ampersand (&&) operator ensures the second command runs only if the first succeeds. Adding -y flag automatically confirms installation prompts, streamlining the process.

Verify available disk space before installing development tools. Run df -h to display filesystem usage in human-readable format. Ensure at least 10 GB remains free. Creating system backups protects against potential installation issues. Ubuntu’s built-in Timeshift utility or manual file backups safeguard important data. Reboot your system after major updates complete: sudo reboot. This applies kernel updates and ensures all services start cleanly.

Installing Build-Essential Package

The build-essential package serves as the cornerstone of Ubuntu development environments. This meta-package bundles fundamental compilation tools required for building software from source code. It includes the GNU Compiler Collection (GCC) for C programming, G++ compiler for C++ development, GNU Make build automation utility, and essential development libraries.

Install build-essential with this single command:

sudo apt install build-essential

Press Enter and provide your password when prompted. The package manager calculates dependencies and displays required disk space. Confirm installation by typing ‘Y’ and pressing Enter. The installation process downloads and configures multiple components including:

• gcc: GNU C compiler translating C source code into executable programs
• g++: GNU C++ compiler supporting object-oriented programming
• make: Build automation tool executing compilation rules from Makefiles
• libc6-dev: GNU C Library development files providing standard functions
• dpkg-dev: Debian package development tools for building .deb packages

Verify successful installation by checking compiler versions:

gcc --version
g++ --version
make --version

Each command should display version information confirming proper installation. Ubuntu 24.04 LTS typically includes GCC version 13.2 or newer. Build-essential proves essential for compiling kernel modules, building custom software, and installing packages from source repositories. Many programming language installations depend on these foundational tools.

Installing Additional Compilers and Development Libraries

Comprehensive development capabilities require supplementary libraries beyond build-essential. These packages provide specialized functionality for different programming scenarios including cryptography, compression, database connectivity, and graphical interfaces.

Install essential development libraries using:

sudo apt install autoconf automake libffi-dev zlib1g-dev libssl-dev

Each package fulfills specific purposes:

Autoconf generates configuration scripts that automatically detect system capabilities. Software distributed as source code uses autoconf to adapt to different Unix-like environments. It examines your system, identifies available libraries, and generates appropriate Makefiles for compilation.

Automake works alongside autoconf creating Makefile templates compliant with GNU Coding Standards. This tool simplifies build process management for complex projects with multiple source files and dependencies.

libffi-dev provides Foreign Function Interface library development files. FFI enables calling code written in one programming language from another, crucial for languages like Python that integrate with C libraries for performance-critical operations.

zlib1g-dev delivers compression library development files. Applications requiring data compression, file archiving, or network protocol implementations depend on zlib. Many database systems and web servers utilize this library internally.

libssl-dev supplies OpenSSL development files for secure communications. Applications implementing HTTPS, SSH, TLS, or other cryptographic protocols require these libraries. Web frameworks, API clients, and security tools depend heavily on OpenSSL.

Extend functionality further by installing additional useful packages:

sudo apt install libbz2-dev libsqlite3-dev libncursesw5-dev tk-dev libreadline-dev liblzma-dev

These libraries support bzip2 compression, SQLite database development, terminal handling, Tkinter GUI development, interactive command-line interfaces, and LZMA compression algorithms respectively.

For kernel module development, install Dynamic Kernel Module Support:

sudo apt install dkms linux-headers-$(uname -r)

The $(uname -r) command substitution automatically inserts your current kernel version, ensuring matching header files installation.

Setting Up Git Version Control System

Git represents the industry standard for distributed version control, enabling code tracking, collaboration, and project management. Modern software development workflows depend fundamentally on Git for managing source code changes, branching strategies, and team coordination.

Install Git from Ubuntu repositories:

sudo apt install git

Confirm installation by checking the version:

git --version

Ubuntu 24.04 typically includes Git 2.43 or newer versions. After installation, configure your identity for commit attribution:

git config --global user.name "Your Full Name"
git config --global user.email "your.email@example.com"

Replace placeholder text with your actual name and email address. These details appear in commit logs and establish authorship. Configure your preferred text editor for Git operations:

git config --global core.editor "nano"

Substitute “nano” with “vim”, “code”, or your preferred editor. Set the default branch name following modern conventions:

git config --global init.defaultBranch main

This changes default branch naming from “master” to “main”. Review all configurations:

git config --list

For secure authentication with remote repositories like GitHub, GitLab, and Bitbucket, generate SSH keys:

ssh-keygen -t ed25519 -C "your.email@example.com"

Press Enter to accept default file location. Optionally set a passphrase for additional security. Display your public key:

cat ~/.ssh/id_ed25519.pub

Copy this key and add it to your Git hosting service account settings. Test SSH connectivity to GitHub:

ssh -T git@github.com

Successful connection confirms proper SSH key configuration. Git fundamentals enable cloning repositories, committing changes, creating branches, merging code, and pushing updates to remote servers.

Installing Python Development Tools

Ubuntu 24.04 LTS ships with Python 3.12 pre-installed as the default Python 3 interpreter. However, professional Python development requires additional tools including package managers, virtual environment support, and development headers.

Verify your Python version:

python3 --version

Install Python development package containing header files needed for compiling Python extensions:

sudo apt install python3-dev

Install pip, Python’s package installer managing third-party libraries:

sudo apt install python3-pip

Confirm pip installation:

pip3 --version

Virtual environments isolate project dependencies preventing version conflicts between different projects. Install virtual environment support:

sudo apt install python3-venv

Create a virtual environment for a new project:

python3 -m venv myproject_env

Activate the virtual environment:

source myproject_env/bin/activate

Your terminal prompt changes indicating active environment. Install packages within this isolated space:

pip install requests flask numpy

Deactivate when finished:

deactivate

Ubuntu 24.04 implements PEP 668 restricting system-wide pip installations. This prevents accidentally breaking system Python packages. Always use virtual environments for project-specific dependencies.

For installing alternative Python versions, use the deadsnakes PPA:

sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update
sudo apt install python3.11 python3.11-venv python3.11-dev

Install common Python development tools:

pip install pylint black pytest ipython jupyter

These provide code linting, automatic formatting, testing frameworks, enhanced interactive shells, and notebook environments respectively. Python’s extensive ecosystem supports web development, data science, machine learning, automation, and system administration tasks.

Installing Node.js and NPM

Node.js enables JavaScript execution outside web browsers, powering server-side applications, build tools, and command-line utilities. NPM (Node Package Manager) manages JavaScript dependencies and project scripts.

Ubuntu repositories provide stable Node.js versions. Install using:

sudo apt install nodejs npm -y

Verify installations:

node --version
npm --version

Repository versions prioritize stability but may lag behind latest releases. For cutting-edge versions, use NodeSource repositories. Install Node.js 20.x LTS:

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo bash -
sudo apt install nodejs -y

Replace setup_20.x with setup_18.x or setup_22.x for different versions. Verify installation includes NPM:

node --version
npm --version

Update NPM to latest version:

sudo npm install -g npm@latest

The -g flag installs packages globally, making them available system-wide. Create a new Node.js project:

mkdir myapp
cd myapp
npm init -y

This generates package.json tracking project metadata and dependencies. Install packages:

npm install express axios dotenv

Package.json automatically records dependencies. Install development dependencies:

npm install --save-dev nodemon eslint prettier

Run scripts defined in package.json:

npm start
npm test
npm run dev

Node Version Manager (NVM) provides an alternative approach managing multiple Node.js versions simultaneously. Install NVM:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

Reload shell configuration:

source ~/.bashrc

Install Node.js versions with NVM:

nvm install 20
nvm install 18
nvm use 20

Node.js powers modern web development frameworks including React, Vue, Angular, Express, and Next.js. Build tools like Webpack, Vite, and Rollup depend on Node.js infrastructure.

Installing Docker for Containerization

Docker revolutionizes development workflows through lightweight containerization technology. Containers package applications with dependencies, ensuring consistent behavior across different environments. Docker eliminates “works on my machine” problems by standardizing deployment configurations.

Install prerequisite packages:

sudo apt install curl apt-transport-https ca-certificates software-properties-common

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 Docker 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

Update package index:

sudo apt update

Install Docker Engine with all components:

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Verify Docker service runs properly:

sudo systemctl status docker

Test Docker installation:

sudo docker run hello-world

Docker downloads a test image, creates a container, executes it, and displays confirmation message. Add your user account to docker group avoiding sudo requirement:

sudo usermod -aG docker $USER

Log out and log back in for group changes to take effect. Alternatively, activate group immediately:

newgrp docker

Test Docker without sudo:

docker run hello-world

Docker Compose manages multi-container applications. The docker-compose-plugin includes Compose V2 functionality. Create a docker-compose.yml file:

version: '3.8'
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"

Start services:

docker compose up -d

View running containers:

docker ps

Docker transforms development by providing isolated environments, simplified dependency management, and reproducible builds. Microservices architectures, continuous integration pipelines, and cloud-native applications leverage Docker extensively.

Installing Integrated Development Environments (IDEs)

Integrated Development Environments combine code editors, debuggers, build tools, and project management features into unified applications. Choosing appropriate IDEs enhances productivity through intelligent code completion, refactoring tools, and integrated testing capabilities.

Visual Studio Code dominates as the most popular lightweight IDE supporting numerous programming languages through extensions. Install via Snap:

sudo snap install code --classic

The --classic flag grants necessary system permissions. Alternatively, download the .deb package from code.visualstudio.com. Install using:

sudo dpkg -i code_*.deb
sudo apt install -f

Launch VS Code from applications menu or terminal:

code

Install essential extensions through Extensions panel (Ctrl+Shift+X): Python, Pylance, ESLint, Prettier, GitLens, Docker, and Live Server.

IntelliJ IDEA Community Edition excels for Java development with powerful refactoring and debugging capabilities. Install via Snap:

sudo snap install intellij-idea-community --classic

PyCharm Community Edition specializes in Python development. Install using:

sudo snap install pycharm-community --classic

Ubuntu Make simplifies installing multiple IDEs. Install Ubuntu Make:

sudo apt install ubuntu-make

View available IDEs:

umake --list

Install PyCharm through Ubuntu Make:

umake ide pycharm

Install Android Studio for mobile development:

umake android

Eclipse supports Java, C/C++, and PHP development. Download from eclipse.org or install via Snap:

sudo snap install eclipse --classic

For AppImage-based IDEs, install FUSE support:

sudo apt install libfuse2t64

Download AppImage files, make them executable, and run:

chmod +x application.AppImage
./application.AppImage

Select IDEs based on your primary programming languages, project complexity, and personal preferences. VS Code offers versatility across languages. JetBrains IDEs provide language-specific power features. Eclipse suits enterprise Java development.

Troubleshooting Common Issues

Installation challenges occasionally arise despite careful preparation. Understanding common problems and solutions ensures smooth development environment setup.

Dependency Errors occur when packages require unavailable or conflicting dependencies. Fix broken dependencies:

sudo apt --fix-broken install

This command resolves dependency conflicts automatically. If problems persist, examine specific package details:

apt show package-name

Unable to Locate Package errors indicate missing repositories or outdated package lists. Refresh package information:

sudo apt update

Verify repository configuration in /etc/apt/sources.list. Ensure main, universe, restricted, and multiverse repositories are enabled.

Permission Denied errors happen when executing commands requiring administrative privileges without sudo. Prefix commands with sudo:

sudo command-name

For Docker specifically, ensure your user belongs to docker group:

groups $USER

If docker doesn’t appear, add yourself:

sudo usermod -aG docker $USER

Disk Space Insufficient prevents package installations. Check available space:

df -h

Remove unnecessary packages:

sudo apt autoremove
sudo apt clean

Clear package cache:

sudo rm -rf /var/cache/apt/archives/*

Network Connectivity Issues disrupt package downloads. Test connectivity:

ping -c 4 google.com

For proxy environments, configure proxy settings:

export http_proxy=http://proxyserver:port/
export https_proxy=https://proxyserver:port/

Make proxy settings persistent by adding lines to ~/.bashrc.

GPG Key Errors occur when repository keys expire or fail verification. Update expired keys:

sudo apt-key adv --refresh-keys --keyserver keyserver.ubuntu.com

Version Compatibility Problems arise when tools require specific dependency versions. Check compatibility documentation before installation. Use virtual environments isolating conflicting versions.

Installation Hangs during package configuration suggest interactive prompts requiring input. Run installations with -y flag for automatic confirmation:

sudo apt install -y package-name

Review system logs for detailed error information:

journalctl -xe

Search Ubuntu forums, Ask Ubuntu Stack Exchange, and official documentation for specific error messages. The Ubuntu community provides extensive troubleshooting resources.

Congratulations! You have successfully installed Development Tools. Thanks for using this tutorial for installing Development Tools on the Ubuntu 24.04 LTS system. For additional help or useful information, we recommend you check the official Ubuntu website.