1. Install via live USB: `sudo add-apt-repository ppa:yannubuntu/boot-repair && sudo apt update && sudo apt install boot-repair`
2. Run: `sudo boot-repair`
3. Select "Recommended repair".

"Boot-Repair is a user-friendly tool that can fix many boot issues automatically. It will detect your OS and hardware configuration and apply the necessary fixes."

Success: "The bootloader has been successfully repaired."

Failure: "No changes were made; manual intervention required."

1. Mount partitions as shown earlier.
2. Enter chroot: `sudo chroot /mnt/ubuntu`
3. Run

   Optimizing Ubuntu for Faster Boot Times

   Ubuntu’s boot process can be significantly accelerated through targeted optimizations, particularly by reducing unnecessary service overhead, leveraging parallel execution in `systemd`, and preloading critical kernel components. These adjustments minimize idle CPU cycles and I/O bottlenecks, resulting in measurable improvements in total boot duration—often reducing it by 20–50% on standard hardware. This section provides actionable techniques to refine Ubuntu’s startup sequence while maintaining system stability, supported by empirical benchmarks and configuration best practices.
   

   Disabling Unnecessary Services to Reduce Boot Overhead

   Ubuntu boots numerous services by default, many of which are redundant for typical use cases (e.g., Bluetooth, network discovery, or printer spooling). Disabling these services via `systemctl` eliminates redundant processes from the boot sequence, directly lowering initialization time. Critical services—such as `systemd-logind`, `dbus`, or `network-manager`—should remain active, while peripheral services can be safely deactivated.

   To identify and disable safe services:
   1. List all active services:
   ```bash
   systemctl list-units --type=service --state=running
   ```
   Filter for non-essential services using:
   ```bash
   systemctl list-units --type=service --state=running --no-pager | grep -E 'bluetooth|avahi|cups|whoopsie|snapd|apport'
   ```

   2. Disable non-critical services (example commands):
   ```bash
   sudo systemctl disable --now bluetooth.service avahi-daemon.service cups.service
   ```
   Safe services to disable (verify with `systemctl is-enabled ` before disabling):
   

4. `bluetooth.service` (unless required for peripherals)
5. `avahi-daemon.service` (mDNS/ZeroConf, often unused)
6. `cups.service` (printer spooling, disable if no printers are used)
7. `whoopsie.service` (error reporting, non-critical)
8. `snapd.service` (Snap package manager, disable if using `.deb` exclusively)
9. `apport.service` (crash reporting, optional)

3. Verify impact:
Reboot and monitor boot logs (`journalctl -b`) to ensure no critical failures occur. Use `systemd-analyze blame` to confirm reduced service startup delays.


Configuring Parallel Boot with `systemd` for Reduced Latency

`systemd` traditionally processes services sequentially, leading to cumulative delays. Parallel execution mitigates this by allowing independent services to initialize concurrently, provided dependencies are resolved. Adjustments to `systemd`’s configuration file (`/etc/systemd/system.conf`) enable this behavior, though improper settings may introduce race conditions.

Key optimizations:


10. Enable parallel unit processing:
Edit `/etc/systemd/system.conf` and uncomment/modify:
```ini
DefaultDependencies=no
Parallelization=max-jobs:20
```

11. `DefaultDependencies=no`: Disables default dependency ordering (use cautiously; manual dependency management is required).
12. `Parallelization=max-jobs:20`: Limits concurrent jobs to 20 (adjust based on CPU cores).

- Optimize service ordering:
Use `systemd-analyze critical-chain` to identify bottlenecks, then reorder services with `After=` and `Requires=` directives in unit files (e.g., `/etc/systemd/system/multi-user.target.wants/`).

- Impact analysis:
Parallel boot reduces boot time by 10–30% on multi-core systems but may increase memory usage. Test with `systemd-analyze time` before/after changes:
```bash
systemd-analyze time --log-level=debug
```
Warning: Avoid disabling `systemd-logind` or core services, as this may break session management.


Preloading Kernel Modules and Optimizing `initramfs`

Kernel modules (e.g., `nvidia`, `zfs`, `ext4`) are loaded dynamically during boot, adding latency. Preloading them via `/etc/modules-load.d/` ensures they are available immediately, while optimizing `initramfs` reduces decompression overhead—a common bottleneck in early boot phases.

1. Preload critical modules:
Create `/etc/modules-load.d/custom.conf` with module names:
```plaintext
nvidia
zfs
nls_iso8859-1
```
Verify with:
```bash
lsmod | grep nvidia # Confirm module is loaded at boot
```

2. Optimize `initramfs`:


13. Compression: Use `zstd` (faster decompression than `gzip`):
```bash
sudo update-initramfs -u -k all -c zstd
```

14. Exclude unnecessary modules: Edit `/etc/initramfs-tools/modules` to remove unused entries (e.g., `squashfs` if not required).
15. Benchmark decompression:
```bash
time sudo initramfs-tools -u -k $(uname -r) # Measure rebuild time
```

3. Verify `initramfs` size and speed:
Check compressed size:
```bash
ls -lh /boot/initrd.img-$(uname -r)
```
Smaller `initramfs` files decompress faster, reducing early-boot latency.


Benchmarking Boot Performance Before and After Optimizations

Quantitative analysis validates optimization efficacy. The following script captures key metrics: total boot time, service startup delays, and kernel initialization duration. Compare results before/after changes to assess improvements.

Boot Benchmark Script (`/usr/local/bin/boot_benchmark.sh`):
```bash
#!/bin/bash


Requires: systemd, journalctl, time

echo "=== Boot Performance Analysis ==="

# Total boot time (wall-clock)
echo -e "\n[Total Boot Time]"
systemd-analyze time | grep "Startup finished in"

# Service startup delays (longest tasks)
echo -e "\n[Critical Chain]"
systemd-analyze critical-chain

# Kernel initialization duration
echo -e "\n[Kernel Initialization]"
systemd-analyze blame | head -n 10

# Service parallelization stats
echo -e "\n[Parallelization Metrics]"
systemd-analyze time --log-level=debug | grep -E "parallel|serial"

# Journalctl boot duration (alternative)
echo -e "\n[Journalctl Boot Log Duration]"
journalctl --boot | grep "systemd" | head -n 5

echo -e "\n=== Benchmark Complete ==="
```

Key Metrics to Monitor:


16. Total boot time: Target <10 seconds on SSD-based systems.
17. Critical chain: Identify services exceeding 1-second delays (e.g., `NetworkManager-wait-online`).
18. Kernel initialization: Should complete in <1 second on modern hardware.
19. Parallelization: Higher job counts correlate with faster boots (e.g., `20 parallel jobs` vs. default `1`).

Example Output Interpretation:
```plaintext
Startup finished in 4.234s (kernel) + 5.123s (userspace) = 9.357s
Critical Chain: systemd → NetworkManager-wait-online.service (1.2s) → ...
```
A reduction from 12s → 8s indicates successful optimizations.

Customizing the Boot Experience in Ubuntu

The boot process in Ubuntu, governed by GRUB (GRand Unified Bootloader) and Plymouth (the display manager for early userspace), can be tailored to enhance aesthetics, functionality, and performance. Customizations range from modifying GRUB’s appearance—such as themes, timeout delays, and resolution—to integrating splash screens and managing custom boot entries. This guide provides structured instructions for editing core configuration files, leveraging tools like `grub-customizer`, and adjusting system-level parameters to achieve a personalized boot experience while maintaining stability.


Modifying GRUB’s Appearance and Configuration

GRUB’s behavior is controlled by `/etc/default/grub`, a configuration file where variables define timeout, resolution, theme support, and kernel parameters. Changes to this file require regeneration of `grub.cfg` using `grub-mkconfig` to apply modifications. Below are key variables and their customization methods, along with best practices to avoid boot failures.


Critical Note:
Always back up `/etc/default/grub` before editing and verify syntax with `sudo grub-mkconfig -t` before regenerating `grub.cfg`. Incorrect configurations may render the system unbootable.

Key GRUB Variables and Their Customizations

The following table outlines essential GRUB variables, their default values, customization options, and whether a reboot is required for changes to take effect.


Variable	Default Value	Customization Options	Reboot Required	Description
GRUB_TIMEOUT	5 (seconds)	Set to 0 for automatic boot (no selection screen). Increase to 10 or higher for longer delays (e.g., GRUB_TIMEOUT=15). Use GRUB_TIMEOUT_STYLE=menu to show timeout countdown.	Yes	Controls the time (in seconds) before automatic boot.
GRUB_CMDLINE_LINUX_DEFAULT	"" (empty)	Add kernel parameters (e.g., "quiet splash" for reduced boot messages). Disable splash screen with "nosplash". Enable serial console with "console=ttyS0,115200n8".	Yes	Passes default kernel command-line options.
GRUB_GFXMODE	auto or 1920x1080x32 (depends on system)	Set to "1280x720" for lower resolutions (e.g., laptops). Use "keep" to retain the previous boot’s resolution. For UEFI systems, ensure the mode is supported by the GPU.	Yes	Defines the display resolution for GRUB.
GRUB_TERMINAL_OUTPUT	gfxterm (for graphical output)	Set to "console" for text-only mode (useful for headless servers). Combine with GRUB_GFXPAYLOAD_LINUX=keep to preserve console resolution.	Yes	Specifies the output terminal type (graphical or text).
GRUB_THEME	"" (no theme)	Set to "/boot/grub/themes/mytheme/theme.txt" for custom themes. Install themes via sudo add-apt-repository ppa:danielrichter2007/grub-customizer and sudo apt install grub2-themes-*. Ensure the theme directory is readable by GRUB.	Yes	Loads a custom GRUB theme (requires gfxterm support).
GRUB_BACKGROUND	"" (no background image)	Set to "/path/to/image.png" for a static background. Use GRUB_GFXMODE to ensure the image resolution matches the display.	Yes	Applies a background image to the GRUB menu (requires gfxterm).

Applying GRUB Configuration Changes

After editing `/etc/default/grub`, regenerate the GRUB configuration file with:

sudo update-grub # For BIOS systems
sudo grub-mkconfig -o /boot/grub/grub.cfg # For UEFI systems (explicit path)

For UEFI systems, ensure the EFI partition is mounted and accessible. Verify the changes by rebooting and checking the GRUB menu.


Adding Custom Entries to GRUB

Custom boot entries in GRUB enable advanced use cases, such as dual-booting Windows, booting recovery kernels, or testing older kernel versions. Two primary methods exist: manual configuration via `/etc/grub.d/40_custom` or using GUI tools like `grub-customizer`.

#### Method 1: Manual Configuration with `/etc/grub.d/40_custom`
The `/etc/grub.d/40_custom` file allows adding custom entries without modifying the main GRUB scripts. Each entry must follow the syntax:

menuentry "Custom Entry Name" {
linux /boot/vmlinuz- root=UUID= ro quiet splash
initrd /boot/initrd.img- }

Steps:
1. Open the file with elevated privileges:

sudo nano /etc/grub.d/40_custom

2. Add the following example for a Windows 10 dual-boot entry (adjust paths and UUIDs):

menuentry "Windows 10 (on /dev/nvme0n1p1)" {
insmod ntfs
set root='hd0,gpt1'
chainloader +1
}

- Replace `hd0,gpt1` with the correct partition identifier (use `lsblk -f` to find NTFS partitions).


20. For UEFI systems, ensure the EFI System Partition (ESP) is targeted.
3. Set executable permissions:

sudo chmod +x /etc/grub.d/40_custom

4. Regenerate `grub.cfg`:

sudo update-grub

#### Method 2: Using `grub-customizer` for GUI Management
`grub-customizer` provides a user-friendly interface to manage GRUB entries without manual editing. Install it via:

sudo add-apt-repository ppa:danielrichter2007/grub-customizer
sudo apt update && sudo apt install grub-customizer

Features:


21. Drag-and-drop reordering of boot entries.
22. Enable/disable entries without deleting them.
23. Edit kernel parameters for existing entries.
24. Add custom entries with a graphical interface.

Example Workflow:
1. Launch `grub-customizer` from the application menu.
2. Navigate to the "Advanced" tab to add a new entry

Understanding and controlling the boot process in Ubuntu empowers users to transform potential challenges into opportunities for optimization and customization. By systematically addressing compatibility checks, troubleshooting failures, and refining system behavior, administrators can achieve faster boot times, resolve persistent issues, and personalize their environment to meet specific workflow demands. The insights shared here—ranging from GRUB customization to service prioritization—serve as a foundation for both routine maintenance and advanced configurations, ensuring Ubuntu remains a robust and adaptable platform for diverse computing needs.

Ultimately, this guide equips readers with the tools and methodologies to navigate the intricacies of Ubuntu’s boot process with confidence. Whether restoring a failed system, fine-tuning performance, or integrating dual-boot setups, the structured approach outlined here ensures clarity and precision. By mastering these essentials, users can elevate their technical proficiency and harness Ubuntu’s full potential in both professional and personal computing environments.