Stații de lucru

How to install Puppy Linux

• Data 06/08/2026
• Autor Daniel Ionica
• 6
• 152

Puppy Linux is a lightweight Linux distribution designed to run efficiently on both modern and older computers. Unlike many Linux distributions, Puppy is designed to be fast, portable, and capable of running entirely from RAM, resulting in quick boot times and responsive performance.

Some notable features include:

• Extremely small download size
• Low memory usage
• Runs entirely from RAM (on systems with sufficient memory)
• Can operate without a traditional installation
• Excellent support for older hardware
• Easy backup through save files or save folders
• Includes a large collection of built-in applications

Several Puppy Linux variants are available, each built on different package ecosystems.

Popular choices include:

• Ubuntu-based Puppy (compatible with Ubuntu packages)
• Debian-based Puppy (compatible with Debian repositories)
• Slackware-based Puppy
• Official Puppy Linux community releases

When selecting a version, consider:

• Hardware age
• Required software compatibility
• Available RAM
• Processor architecture (64-bit or 32-bit)

For most modern systems, a recent 64-bit release is recommended.

Requirements

• USB flash drive (4 GB or larger)
• Internet connection
• ISO image
• USB writing utility

Download the desired Puppy Linux ISO. Verify the checksum if one is provided. Create a bootable USB using your preferred imaging utility.

1. Insert the USB drive
2. Enter the computer’s boot menu
3. Select the USB device
4. Boot Puppy Linux.

Most versions present a boot menu with default options.Choose the default entry unless you require special hardware options.

Puppy usually starts directly into the desktop. Unlike many Linux distributions, you are often logged in automatically.

The desktop typically includes:

• File manager
• Terminal
• Browser
• Package Manager
• Setup Wizard
• System utilities

Run the setup wizard if it does not start automatically.

Configure:

• Keyboard layout
• Display resolution
• Time zone
• Language
• Locale
• Hostname (if applicable)

Apply the settings.

Wired Ethernet

Most wired connections are configured automatically.Verify connectivity by opening a browser or using:

ping puppylinux.com

Wi-Fi

Open the Network Wizard.

Select:

• Wireless adapter
• Available network
• Enter Wi-Fi password
• Connect

Save the profile for automatic reconnection.

Puppy Linux can operate in several ways:

Live USB

Runs directly from the USB drive.

Advantages:

• No changes to internal disks
• Portable
• Easy testing

The recommended installation method.

Characteristics:

• Uses only a few files
• Shares partitions with other operating systems
• Easy upgrades
• Supports save files
• Fast booting

A traditional Linux installation. Generally recommended only for specific use cases such as systems with very limited RAM or specialized requirements.

Launch the Puppy Installer.

Select:

• Internal drive
• Target partition

Copy:

• vmlinuz
• initrd
• Main Puppy SFS file
• Additional SFS modules if required

Install a bootloader.

Most recent systems use GRUB.Legacy BIOS systems may use GRUB Legacy or GRUB4DOS depending on the Puppy version.Reboot.

One unique Puppy Linux feature is persistent storage.When shutting down for the first time, Puppy asks whether to save your session.Options include:

Advantages:

• Portable
• Easy backup
• Fixed size

Typical sizes:

• 512 MB
• 1 GB
• 2 GB
• Larger as needed

Advantages:

• Dynamic size
• Better for large storage devices
• No predefined size limit

Generally preferred on Linux-native filesystems.

Important directories include:

/root

Default home directory.

/mnt

Mounted drives.

/etc

System configuration.

/usr

Applications.

/var

Logs and runtime data.

Unlike rolling distributions, Puppy updates vary depending on the specific release.

Recommended approach:

• Update package repositories
• Install security updates when available
• Upgrade individual applications as needed
• Consider upgrading to a newer Puppy release periodically.

Open Puppy Package Manager.

Features include:

• Search packages
• Install software
• Remove packages
• Manage repositories
• View dependencies

Depending on the Puppy variant, packages may originate from:

• Ubuntu
• Debian
• Slackware
• Puppy repositories

Examples include:

Development:

• GCC
• Make
• CMake

Office:

• LibreOffice

Graphics:

• GIMP
• Inkscape

Media:

• VLC
• Audacity

Development tools:

• Git
• Python
• Node.js

Many Puppy releases include a lightweight browser.

Alternatives include:

• Firefox
• Chromium
• Pale Moon (where available)
• Other compatible browsers

Install using the Puppy Package Manager or the package format supported by your Puppy variant.

Open:

Setup → Sound Wizard

Verify:

• Audio output
• Microphone
• Volume levels

Use the mixer utility to adjust sound levels.

Open:

Printer Setup

Typical workflow:

1. Detect printer.
2. Install drivers if necessary.
3. Configure the printer.
4. Print a test page.

Many network printers are automatically detected.

Open the display configuration utility.

Adjust:

• Resolution
• Refresh rate
• Multi-monitor settings (if supported)
• Screen orientation

Apply and test changes.

Most hardware drivers are included in the Linux kernel.For proprietary graphics or wireless hardware, consult the documentation for your Puppy Linux variant to determine whether additional drivers are available.After installation, reboot if prompted.

For software development, install:

• GCC
• G++
• Make
• Git
• CMake
• Python
• OpenJDK (if needed)

Many Puppy releases also provide a “devx” SFS module containing compilers and development libraries that can be loaded without permanently installing every development package.

Applications can be started automatically during login.

Common startup items include:

• Cloud synchronization
• Clipboard managers
• Custom scripts
• Monitoring tools

Review the startup configuration provided by your Puppy version before adding applications.

Recommended backup strategy:

• Backup the save file or save folder regularly
• Backup personal files separately
• Keep copies on an external drive
• Test restoring backups occasionally.

Because most personal changes are stored in the save file/folder, copying it is often sufficient to preserve your environment.

• Reduce startup applications
• Remove unused packages
• Use lightweight applications
• Clear browser caches periodically.
• Unload unnecessary services.

Puppy Linux is already highly optimized, so these steps generally yield modest improvements.

Recommendations:

• Use strong passwords where applicable.
• Enable the firewall if your Puppy version provides one.
• Install software only from trusted repositories.
• Keep applications updated.
• Avoid running unknown software with elevated privileges.

Recommended software:

Productivity

• LibreOffice
• AbiWord

Internet

• Firefox
• Chromium

Media

• VLC
• MPV

Graphics

• GIMP
• Inkscape

Utilities

• GParted
• htop
• rsync

Development

• Git
• Python
• GCC.

NixOS installation guide

• Data 06/08/2026
• Autor Daniel Ionica
• -4
• 154

NixOS is a Linux distribution built around the Nix package manager, where the entire operating system is described as code. Instead of manually installing software and editing configuration files, you define your desired system state in configuration files.

Advantages include:

• Fully reproducible systems
• Atomic upgrades and rollbacks
• Declarative package management
• Reliable dependency isolation
• Easy migration between machines
• Excellent development environments

Part 1 – Preparation

Requirements

• 8 GB RAM minimum (16 GB recommended)
• 30+ GB storage
• USB flash drive (4 GB or larger)
• Internet connection
• UEFI firmware (recommended)

Download the latest NixOS ISO and verify its checksum before writing it to a USB drive.

1. Boot from the installation USB.
2. Select the graphical installer or minimal installer.
3. Open a terminal.

Become root if necessary:

sudo -i

Confirm networking:

ping nixos.org

List disks:

lsblk

Example:

nvme0n1
├─nvme0n1p1
├─nvme0n1p2

Assume:

Disk:
/dev/nvme0n1

Using GPT:

parted /dev/nvme0n1 -- mklabel gpt

EFI partition:

parted /dev/nvme0n1 -- mkpart ESP fat32 1MiB 512MiB
parted /dev/nvme0n1 -- set 1 esp on

Root:

parted /dev/nvme0n1 -- mkpart primary 512MiB 100%

Format EFI:

mkfs.fat -F32 /dev/nvme0n1p1

Format root:

mkfs.ext4 /dev/nvme0n1p2

mount /dev/nvme0n1p2 /mnt

mkdir -p /mnt/boot

mount /dev/nvme0n1p1 /mnt/boot

nixos-generate-config --root /mnt

Files created:

/mnt/etc/nixos/configuration.nix

/mnt/etc/nixos/hardware-configuration.nix

Edit:

nano /mnt/etc/nixos/configuration.nix

Example:

{ config, pkgs, ... }:

{
  imports = [
    ./hardware-configuration.nix
  ];

  boot.loader.systemd-boot.enable = true;

  boot.loader.efi.canTouchEfiVariables = true;

  networking.hostName = "desktop";

  time.timeZone = "Europe/Bucharest";

  i18n.defaultLocale = "en_US.UTF-8";

  services.xserver.enable = true;

  services.displayManager.gdm.enable = true;

  services.desktopManager.gnome.enable = true;

  users.users.alex = {
    isNormalUser = true;
    extraGroups = [ "wheel" "networkmanager" ];
  };

  networking.networkmanager.enable = true;

  environment.systemPackages = with pkgs; [
    git
    vim
    wget
    curl
  ];

  system.stateVersion = "26.05";
}

nixos-install

Set root password.

Reboot:

reboot

Remove the USB.

Edit:

/etc/nixos/configuration.nix

Add:

nix.settings.experimental-features = [
  "nix-command"
  "flakes"
];

Rebuild:

sudo nixos-rebuild switch

Directory:

/etc/nixos

Create:

flake.nix

Example:

{
  description = "Desktop";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
  };

  outputs = { self, nixpkgs }:

  {
    nixosConfigurations.desktop =
      nixpkgs.lib.nixosSystem {
        system = "x86_64-linux";

        modules = [
          ./configuration.nix
        ];
      };
  };
}

Rebuild:

sudo nixos-rebuild switch --flake /etc/nixos#desktop

Temporarily:

nix shell nixpkgs#ripgrep

Run once:

nix run nixpkgs#hello

Permanent:

environment.systemPackages = with pkgs; [
  firefox
  git
  neovim
  ripgrep
  fd
  htop
  tmux
];

Install Home Manager as a flake input.

Benefits:

• User configuration as code
• Dotfile management
• Reproducible shell configuration
• Declarative editor setup
• Version-controlled user environment

Example modules:

• Git
• Zsh
• Bash
• Neovim
• Alacritty
• Kitty
• VS Code
• SSH
• GPG
• Starship

Delete old generations:

sudo nix-collect-garbage -d

Automatic cleanup:

nix.gc = {
  automatic = true;
  dates = "weekly";
  options = "--delete-older-than 30d";
};

List generations:

sudo nix profile history

Rollback:

sudo nixos-rebuild switch --rollback

You can also select previous system generations directly from the bootloader if a rebuild prevents the system from booting.

Update flake inputs:

nix flake update

Apply:

sudo nixos-rebuild switch --flake /etc/nixos

SSH:

services.openssh.enable = true;

Docker:

virtualisation.docker.enable = true;

PipeWire:

services.pipewire = {
  enable = true;
  pulse.enable = true;
};

Printing:

services.printing.enable = true;

Bluetooth:

hardware.bluetooth.enable = true;

Example development shell:

{
  description = "Example dev shell";

  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";

  outputs = { self, nixpkgs }:
  let
    pkgs = import nixpkgs {
      system = "x86_64-linux";
    };
  in {
    devShells.x86_64-linux.default =
      pkgs.mkShell {
        packages = with pkgs; [
          git
          gcc
          cmake
          python3
        ];
      };
}

Enter:

nix develop

nixos/

├── flake.nix
├── flake.lock
├── hosts/
│   └── desktop
├── modules/
│   ├── networking.nix
│   ├── users.nix
│   ├── desktop.nix
│   ├── fonts.nix
│   └── services.nix
├── home/
│   ├── git.nix
│   ├── shell.nix
│   ├── nvim.nix
│   └── zsh.nix

Keeping configuration modular makes it easier to reuse components across multiple systems and simplifies maintenance.

Configuration errors

Validate before switching:

sudo nixos-rebuild test

Boot issues

• Confirm the EFI partition is mounted at /boot.
• Verify boot.loader.systemd-boot.enable = true;.
• Ensure UEFI mode is enabled in firmware.

Network problems

Verify NetworkManager:

systemctl status NetworkManager

Flake errors

Refresh lock file:

nix flake update

Or remove flake.lock and regenerate it if dependency resolution becomes inconsistent.