How to Boot Ubuntu Without GUI and Use Command Line

Maximizing Efficiency and Performance with Ubuntu's Command Line Interface

Key Takeaways

Multiple methods exist to disable the GUI, allowing flexibility based on user needs.
Understanding systemd targets and GRUB configuration is essential for effective boot customization.
Operating without a GUI can enhance system performance, security, and resource management.

Introduction

Ubuntu, one of the most popular Linux distributions, typically boots into a Graphical User Interface (GUI) that provides an accessible environment for users. However, there are scenarios where booting Ubuntu without a GUI and utilizing the Command Line Interface (CLI) is advantageous. Operating in CLI mode can lead to improved system performance, reduced resource consumption, enhanced security, and greater control over system operations. This comprehensive guide explores various methods to boot Ubuntu without a GUI, ensuring users can tailor their system's startup behavior to their specific requirements.

Understanding the Difference: GUI vs. CLI

The GUI offers a visual interface with windows, icons, and buttons, making it user-friendly and intuitive, especially for those less familiar with command-line operations. Conversely, the CLI provides a text-based interface where users execute commands to perform tasks. While the CLI may have a steeper learning curve, it offers greater flexibility, efficiency, and control, particularly beneficial for system administrators, developers, and power users.

Methods to Boot Ubuntu Without GUI

1. Temporary Methods

Temporary methods are ideal for users who need to access the CLI for a single session or specific tasks without altering the system's default boot behavior. These methods allow flexibility and can be easily reverted.

a. Switching to a Virtual Terminal

If you are currently using the GUI and wish to access the CLI without rebooting, switching to a virtual terminal is a straightforward approach.

Access a Virtual Terminal:
Press Ctrl + Alt + F3 (or any function key from F2 to F6) to switch to a text-only virtual console.
Log In:
Enter your username and password when prompted to access the terminal session.
Terminate the GUI Session (Optional):
To stop the GUI, execute the following command:
```
sudo systemctl isolate multi-user.target
```
This command shifts the system to multi-user mode, effectively stopping the GUI.
Return to GUI:
To restart the GUI, you can switch back to the graphical target by executing:
```
sudo systemctl start graphical.target
```
Alternatively, press Ctrl + Alt + F2 or the corresponding function key to return to the GUI.

b. Modifying GRUB Boot Parameters

For users who prefer not to interact with systemd targets, modifying GRUB boot parameters offers another temporary solution to boot into the CLI.

Access the GRUB Menu:
Restart your system. During the boot process, press the Esc or Shift key to display the GRUB menu.
Edit the Boot Entry:
Use the arrow keys to highlight the desired Ubuntu entry and press e to edit it.
Add Boot Parameter:
Locate the line starting with linux and append text or 3 at the end. For example:
```
linux /boot/vmlinuz-xxxxx-generic root=UUID=xxxx ro quiet splash text
```
Adding text sets the system to boot in text mode (runlevel 3).
Boot with Modified Parameters:
Press Ctrl + X or F10 to boot using the modified entry. The system will start in a terminal-based environment for that session.

Note: This change is temporary and will revert upon the next reboot, restoring the default GUI mode.

2. Permanent Methods

Permanent methods configure the system to consistently boot into the CLI, eliminating the GUI from the startup process. This is particularly useful for servers, embedded systems, or environments where the GUI is unnecessary.

a. Using systemd to Set Default Target

Systemd manages system services and targets in modern Ubuntu installations. By setting the default target to multi-user.target, you instruct the system to boot into a non-graphical, multi-user environment.

Set Default Target to Multi-User:
Open a terminal and execute:
```
sudo systemctl set-default multi-user.target
```
This command changes the default boot target from the graphical interface (graphical.target) to the multi-user text mode (multi-user.target).
Reboot the System:
Apply the changes by restarting your computer:
```
sudo reboot
```
Upon reboot, Ubuntu will start in the command line interface by default.

To verify the current default target, you can run:

systemctl get-default

It should return multi-user.target, indicating that the system is set to boot into CLI mode.

b. Modifying GRUB Configuration

Another approach involves configuring GRUB, the GRand Unified Bootloader, to initiate the system in CLI mode by default.

Edit the GRUB Configuration File:
Open the GRUB configuration file using a text editor:
```
sudo nano /etc/default/grub
```
This file controls the GRUB bootloader's behavior.
Modify Boot Parameters:
Locate the line:
```
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
```
and modify it to include text or 3, resulting in:
```
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash text"
```
Adding text instructs GRUB to boot into text mode.
Enable GRUB to Use Text Mode:
Ensure that GRUB outputs to the console by uncommenting or adding the following line:
```
GRUB_TERMINAL=console
```
This setting ensures that GRUB operates in console mode, facilitating text-based booting.
Update GRUB Configuration:
Apply the changes by updating GRUB:
```
sudo update-grub
```
This command regenerates the GRUB configuration based on the modified settings.
Reboot the System:
Restart your computer to apply the new GRUB settings:
```
sudo reboot
```
The system will now boot into the command line interface by default.

By configuring GRUB in this manner, you establish a permanent shift to CLI mode, bypassing the GUI unless explicitly initiated.

c. Disabling GUI Services

Another method involves disabling the display manager service responsible for initiating the GUI. This approach directly targets the services that start the graphical environment.

Identify Your Display Manager:
Ubuntu supports various display managers, such as gdm, lightdm, and sddm. Determine which display manager is active by running:
```
systemctl status display-manager
```
The output will indicate the active display manager service.
Disable the Display Manager:
Replace gdm with your specific display manager if different:
```
sudo systemctl disable gdm
```
This command prevents the display manager from starting automatically at boot.
Stop the Display Manager:
To terminate the GUI immediately without rebooting, execute:
```
sudo systemctl stop gdm
```
This stops the display manager service, returning the system to CLI mode.

By disabling the display manager, you ensure that the GUI does not initiate during the boot process, maintaining the system in CLI mode by default.

Switching Back to GUI Mode

Should you need to revert to the graphical interface after disabling it, the following methods facilitate a smooth transition back to GUI mode.

1. Using systemd to Revert Default Target

Set Default Target to Graphical:
Change the default target back to graphical by executing:
```
sudo systemctl set-default graphical.target
```
This command sets the system to boot into the GUI mode by default.
Reboot the System:
Apply the changes by restarting your computer:
```
sudo reboot
```
Upon reboot, Ubuntu will launch the GUI as the primary interface.

2. Re-enabling the Display Manager

Re-enable the Display Manager Service:
Replace gdm with your specific display manager if necessary:
```
sudo systemctl enable gdm
```
This command reconfigures the display manager to start automatically at boot.
Start the Display Manager:
To initiate the GUI without rebooting, execute:
```
sudo systemctl start gdm
```
This command launches the display manager, bringing up the GUI environment.

These steps ensure that the system returns to its default GUI boot mode, restoring the graphical interface for user interactions.

Additional Configurations and Considerations

Network Management in CLI

Operating in CLI mode necessitates managing network connections through command-line tools. Ubuntu offers several utilities for this purpose:

nmcli: A command-line tool for controlling NetworkManager and reporting network status. It's versatile for managing both wired and wireless connections.
networkctl: Part of systemd, this tool provides status information and control over network interfaces.

For example, to view active network connections using nmcli, execute:

nmcli connection show --active

This command lists all active network connections, allowing you to manage them effectively.

Internet Connectivity

Ensuring reliable internet connectivity is crucial for performing updates and downloading packages in a CLI environment. Utilize the following commands to manage network connections:

Connecting to Wi-Fi:
To connect to a Wi-Fi network, use:
```
nmcli device wifi connect "SSID_NAME" password "PASSWORD"
```
Replace SSID_NAME and PASSWORD with your network's credentials.
Checking Connection Status:
Verify your connection status with:
```
nmcli networking connectivity
```

Basic Command Line Proficiency

Operating solely through the command line requires familiarity with fundamental Linux commands and concepts. Here are some essential commands:

ls: Lists directory contents.
cd: Changes the current directory.
cp: Copies files or directories.
mv: Moves or renames files or directories.
rm: Removes files or directories.
mkdir: Creates new directories.
chmod: Changes file permissions.
chown: Changes file ownership.
grep: Searches for patterns within files.
sudo: Executes commands with superuser privileges.

Developing proficiency with these commands enhances your ability to manage the system efficiently without relying on a GUI.

Starting the GUI Temporarily

If you find yourself in a CLI environment but require temporary access to the GUI, you can start it manually without reverting your default boot settings:

sudo systemctl start graphical.target

This command initiates the graphical interface for the current session. To return to CLI mode without influencing the default boot behavior, you can stop the GUI service:

sudo systemctl stop gdm

Replace gdm with your specific display manager as necessary.

Benefits of Booting Without GUI

Opting to operate Ubuntu without a GUI presents numerous advantages, particularly in environments where system resources are limited or security is paramount:

Enhanced Performance: Without the overhead of rendering graphical elements, the system can allocate more resources to critical processes, resulting in faster performance.
Reduced Resource Consumption: The absence of a GUI significantly lowers CPU and memory usage, which is beneficial for servers, embedded systems, or older hardware.
Improved Security: Fewer running services and open ports associated with the GUI reduce potential attack vectors, enhancing overall system security.
Greater Control and Flexibility: The CLI offers unparalleled control over system operations, allowing for scripting, automation, and precise management of system tasks.
Stability and Reliability: Servers and mission-critical systems benefit from the reduced likelihood of GUI-related crashes or issues, contributing to overall system stability.
Customization: Users can tailor their environments more extensively through CLI configurations, optimizing the system for specific use cases.

Comparative Analysis: Temporary vs. Permanent Boot Methods

Choosing between temporary and permanent methods to disable the GUI depends on your specific needs and use cases. The following table provides a comparative analysis:

Aspect	Temporary Method	Permanent Method
Durability	Reverts after reboot	Persists across reboots
Configuration Complexity	Simple, no configuration changes required	Requires modification of system settings or GRUB configuration
Use Case	One-time tasks, troubleshooting, occasional CLI use	Servers, low-resource systems, routine CLI operations
Ease of Reversion	Easy, simply switch back to GUI	Requires reversing configuration changes
Risk Level	Low, as changes are not persistent	Higher, involves system configuration modifications

Best Practices and Recommendations

To ensure a smooth transition to and operation within a CLI environment, consider the following best practices:

Backup Configurations: Before making permanent changes, backup important configuration files such as /etc/default/grub and any systemd service files.
Maintain Access to GUI: Keep methods to revert to GUI accessible, ensuring you can restore the graphical interface if needed.
Enhance CLI Proficiency: Invest time in learning essential CLI commands and scripting to maximize efficiency in a text-based environment.
Monitor System Resources: Utilize CLI tools like top, htop, and vmstat to monitor system performance and resource usage.
Secure the System: Implement robust security practices, such as configuring firewalls with ufw or iptables, and regularly updating the system to patch vulnerabilities.
Automate Tasks: Leverage scripting languages like Bash or Python to automate routine tasks, enhancing productivity and reducing the potential for human error.

Troubleshooting Common Issues

Transitioning to a CLI environment may present certain challenges. Addressing these promptly ensures consistent system performance:

1. Unable to Access CLI After Disabling GUI

If, after disabling the GUI, you find yourself unable to access the CLI, consider the following steps:

Check Systemd Services: Ensure that essential services are running. Verify the status of multi-user.target:
```
systemctl status multi-user.target
```
Inspect GRUB Configuration: Review the /etc/default/grub file for any syntax errors or misconfigurations.
Access Recovery Mode: Boot into recovery mode from the GRUB menu to revert changes or repair configurations.

2. Display Manager Fails to Stop

If the display manager does not stop as expected, forcing a stop or disabling the service manually may be necessary:

sudo systemctl disable gdm
sudo systemctl stop gdm

Replace gdm with your specific display manager if different.

3. Reverting to GUI Mode

In scenarios where reverting to GUI mode fails, ensure that:

The graphical.target is correctly set as the default target:

sudo systemctl set-default graphical.target

GRUB configuration is correctly modified and updated:

sudo update-grub

Essential GUI packages are installed and not corrupted.

Advanced Configurations

For users seeking a more tailored CLI environment, consider the following advanced configurations:

1. Customizing systemd Targets

Systemd allows for the creation of custom targets, enabling granular control over which services and dependencies are active during boot.

Create a Custom Target:
Copy an existing target as a template:

sudo cp /lib/systemd/system/multi-user.target /etc/systemd/system/my-custom.target

Edit the Custom Target:
Modify the my-custom.target file to include or exclude specific services.

Set the Custom Target as Default:
Execute:

sudo systemctl set-default my-custom.target

This approach allows for the creation of a tailored boot environment suited to specific use cases.

2. Utilizing Screen Sessions

To manage multiple CLI sessions efficiently, tools like screen or tmux can be employed:

Installing Screen:
```
sudo apt install screen
```
Starting a Screen Session:
```
screen
```
Detaching and Reattaching:
Detach with Ctrl + A, D and reattach with:
```
screen -r
```

3. Automating Startup Tasks

Automate routine tasks by creating scripts that execute upon boot. Place your custom scripts in the /etc/init.d/ directory and ensure they have execution permissions:

sudo chmod +x /etc/init.d/my-script.sh
sudo update-rc.d my-script.sh defaults

This ensures that your scripts run automatically during the system's startup process.

Security Implications

Operating in a CLI environment can enhance system security due to the reduced attack surface. However, it also places increased responsibility on the user to manage security settings effectively.

Firewall Configuration: Utilize ufw or iptables to manage incoming and outgoing traffic:
```
sudo ufw enable
sudo ufw allow ssh
```
Regular Updates: Keep the system updated to patch vulnerabilities:
```
sudo apt update && sudo apt upgrade -y
```
User Management: Implement strong password policies and manage user privileges to prevent unauthorized access.

Optimizing System Performance

Operating without a GUI allows for the optimization of system performance by allocating resources more efficiently. Here are methods to ensure your CLI environment runs smoothly:

Lightweight Shells: Consider using lightweight shells like zsh or fish instead of the default bash for improved performance and features.
Minimizing Running Services: Disable unnecessary services to free up system resources:
```
sudo systemctl disable bluetooth.service
```
Resource Monitoring: Regularly monitor system resources using tools like htop, vmstat, and iotop to identify and address bottlenecks.

User Experience Enhancements

Enhance the user experience in a CLI environment with the following tools and configurations:

Command Line Editors: Utilize powerful text editors like vim, nano, or emacs for efficient file editing.
Customizing the Shell: Personalize your shell environment with aliases, functions, and prompt customizations to streamline workflows.
Using Terminal Multiplexers: Tools like tmux or screen facilitate managing multiple terminal sessions within a single window.

Recap and Conclusion

Booting Ubuntu without a GUI and utilizing the command line interface offers substantial benefits in terms of performance, resource management, and security. Whether opting for temporary methods suitable for occasional CLI usage or implementing permanent configurations for dedicated CLI environments, users can tailor their Ubuntu experience to meet specific needs. Mastery of the CLI not only enhances system control and efficiency but also equips users with the skills necessary for advanced system administration and automation.

By following the comprehensive methods and best practices outlined in this guide, users can seamlessly transition Ubuntu's boot process to prioritize the command line, unlocking the full potential of their systems.