Puppy Linux
Puppy Linux is a family of lightweight Linux distributions designed for home users, emphasizing minimal resource usage, portability, and ease of customization on older or low-spec hardware.[1] Originally created by Barry Kauler in 2003 as a smaller, faster alternative to Vector Linux, it pioneered features like running entirely in RAM for enhanced performance and supporting frugal installations on USB drives or CDs without altering the host system.[2][3] Puppy Linux's core strengths include its compact size—typically under 400 MB—allowing it to boot and operate on systems with as little as 256 MB RAM, and its use of modular .pet packages and .sfs squashfs files for efficient software management and system layering.[1][4] It supports a user-friendly JWM window manager, essential applications like web browsers and office tools out of the box, and easy remastering for tailored "puplets" suited to specific tasks, such as multimedia or kiosks.[2] As of November 2025, active development persists through community editions like TrixiePup (Debian 13-based) and Barry Kauler's EasyOS project, based on Devuan/Debian Trixie, with recent releases like EasyOS Excalibur 7.0.30 incorporating kernel 6.12 updates for modern compatibility while maintaining legacy support.[5][6] This evolution has positioned Puppy Linux as a versatile tool for reviving obsolete PCs, portable computing, and educational purposes in resource-limited settings.[3][4]History
Origins and Early Development
Puppy Linux was created by Barry Kauler, an Australian lecturer and software developer with a background in low-level programming, who authored a book on Windows assembly language and systems programming in 1997.[7] Kauler established the Puppy Linux Project in January 2003, transitioning his focus from professional software development to open-source initiatives aimed at enhancing Linux accessibility for non-technical users and those with limited hardware resources.[8] The distribution emerged as a response to the growing resource demands of contemporary Linux distributions, prioritizing simplicity and efficiency to run on older computers.[2] The initial motivations centered on developing a compact Linux distribution that could boot directly from removable media such as CDs, operate primarily from RAM to reduce disk access and enhance speed, and deliver a complete desktop environment suitable for everyday tasks.[2] Kauler envisioned Puppy as a "small, lean, yet complete edition of Linux distribution that was useful from the get-go," incorporating essential applications like a word processor, spreadsheet, and web browser while supporting Live-CD persistence for session saving.[2] Early development emphasized a download size under 100 MB to facilitate distribution via dial-up connections common at the time, targeting users with modest hardware such as Pentium-era systems.[9] Influenced by lightweight distributions like Damn Small Linux and drawing packages from Vector Linux—a Slackware-based system—Puppy incorporated efficient components such as the ROX Filer for file management to optimize performance on aging hardware.[2] The first release, version 0.1, arrived on June 18, 2003, marking the debut of this experimental series focused on minimal persistence without advanced union filesystem features.[9] Subsequent early versions in the 0.x series refined these foundations, leading to the introduction of full filesystem persistence and remastering capabilities in the 1.x series, establishing Puppy's core identity as a portable, RAM-centric operating system.[2]Release History and Milestones
Puppy Linux's release history traces its origins to June 2003, when Barry Kauler released version 0.1 as a lightweight derivative of Vector Linux, emphasizing minimal resource usage for older hardware.[2] Early iterations through the 1.x series (2005) focused on self-compiled packages and introduced unionfs for persistence, while the 2.x series (starting with 2.02 in July 2006) marked a milestone with the implementation of SquashFS layering (SFS files), enabling modular file system overlays for enhanced customization and efficiency.[10][2] This period solidified Puppy's core architecture, with versions like 2.17 (August 2007) improving hardware detection and multi-persistence options across CD, USB, and hard drives.[10] The 3.x series (2007) experimented with Slackware as a base but was short-lived due to compatibility challenges, paving the way for version 4.00 in May 2008, which shifted to the T2 build system and introduced the Woof tool for easier remastering and puplet variants.[10][2] By the 5.x series starting in 2010 (e.g., Wary 5.0.1 in May 2010), Puppy embraced multi-base support, incorporating Ubuntu (Lucid), Slackware, and T2 foundations, allowing concurrent official releases like Precise Puppy (Ubuntu 12.04 base) as a long-term support variant.[2] This era highlighted community contributions, with the first non-Kauler-led official release in the series.[2] A significant milestone occurred in 2014 with the release of Slacko64 6.3.0, the first official 64-bit Puppy Linux based on Slackware 14.1, enabling better performance on modern hardware while maintaining 32-bit compatibility.[11] Following Kauler's retirement in 2013, the community forked the Woof build system into Woof-CE, facilitating decentralized development and the launch of the 6.x series, including Tahrpup 6.0 (October 2014, Ubuntu 14.04 base).[12][2] Woof-CE empowered ongoing variants, such as Slacko 6.3 (2015, Slackware base) and the first fully community-managed 64-bit builds.[13] Subsequent releases expanded base options and modernity: Bionicpup 8.0 (March 2019, Ubuntu 18.04 base) improved repository integration, followed by FossaPup64 9.5 (September 2020, Ubuntu 20.04 base) as the fourth official 64-bit Ubuntu-derived edition.[14][15] Slackware-focused S15Pup64 22.12 arrived in December 2022, leveraging Slackware 15.0 for stability.[16] More recent developments include NoblePup32 24.04 (May 2024, Ubuntu 24.04 base) and BookwormPup64 10.0.12 (September 2025, Debian 12 "Bookworm" base), emphasizing updated kernels and security patches.[17][18] Since Kauler's retirement in 2013, Puppy has lacked a single official lead, relying on team-based maintenance through Woof-CE for these evolutions.[2] Version numbering has evolved from simple sequential schemes (e.g., 5.6 in 2013) to base-specific formats reflecting upstream alignments, such as 9.5 for Ubuntu Focal or 10.0.x for Debian Bookworm, aiding clarity in multi-distro compatibility.[2] This progression underscores Puppy's adaptability, with ongoing releases prioritizing lightweight operation across diverse hardware.[10]Core Features
Lightweight Architecture
Puppy Linux achieves its lightweight architecture through a deliberate selection of minimalistic components that prioritize efficiency and low resource consumption, enabling it to operate effectively on older hardware with limited RAM and storage. The distribution's core is built around BusyBox, a multi-tool utility suite that consolidates hundreds of common Unix commands into a single executable, drastically reducing binary size and dependencies while providing essential functionality for system operations. This is complemented by a minimal Linux kernel, with recent versions such as 6.1 in variants like BookwormPup64 or 6.12 in EasyOS, configured to include only necessary drivers and features to minimize overhead.[19][5] Additionally, the modular file system employs SquashFS for read-only compression of system files into layered ".sfs" modules, allowing on-demand loading that keeps the base installation compact and extensible without bloating the core image.[20][6] Size optimization is a foundational principle, resulting in ISO images ranging from 200 MB for legacy variants to around 800 MB for recent ones like BookwormPup64, as of 2025. This is accomplished through stripped-down libraries, where redundant or heavy components are omitted or replaced with lighter alternatives, ensuring the system remains agile. Puppy Linux eschews resource-intensive init systems like systemd, instead relying on a BusyBox-based init with pup_event for service management, which provides a simple, fast boot process without the complexity or memory demands of more elaborate alternatives. These choices collectively enable the distribution to boot and run with a RAM footprint as low as 100-200 MB idle in 32-bit configurations, on systems with at least 128 MB RAM, emphasizing portability over comprehensive feature sets.[21][20][22][23][4] Portability is enhanced by support for booting from diverse media, including USB drives, optical discs, and even floppy disks in early versions, making it ideal for temporary or hardware-agnostic deployments. Hardware detection leverages simple shell scripts and built-in profiling mechanisms rather than relying on intricate udev rules, allowing quick adaptation to a wide range of devices through modular kernel loading and hotplug scripts that identify and configure peripherals on the fly. This approach ensures seamless operation across legacy and modern systems without requiring extensive configuration.[20][24][25] The architecture's security is bolstered by its immutable design, where the read-only SquashFS layers load entirely into RAM, preventing persistent modifications to the base system and thereby reducing the risk of malware embedding itself across sessions. Optional encryption for persistence files, such as pupsave, further protects user data during frugal installations, allowing secure storage of changes without compromising the lightweight runtime. This RAM-centric execution extends the lightweight goals by isolating the system from disk writes, though detailed persistence mechanisms are covered elsewhere. Recent variants like BookwormPup64 use zstd compression for improved performance. In EasyOS 7.x, persistence uses save-folder exclusively, as of 2025.[20][26][19]RAM-Based Operation and Persistence
Puppy Linux operates primarily from random-access memory (RAM), loading its compressed filesystem during the boot process to enable diskless runtime. The bootloader, such as GRUB, loads the kernel (vmlinuz) and a compressed initrd (initramfs) into RAM, where the kernel unpacks the initrd into a tmpfs root filesystem. This setup mounts layered read-only SquashFS (.sfs) files—containing the core system—over the tmpfs using union filesystems such as OverlayFS (replacing the deprecated AUFS), allowing the entire operating system to run without further disk input/output after initial loading.[27][28][20] Persistence in Puppy Linux is achieved through several mechanisms that overlay changes onto the read-only base system while maintaining RAM-centric operation. The primary methods include a savefile, which is a single overlay file (e.g., pup_save.4fs) that captures session modifications and is mounted as a read-write layer during boot; a savesession, involving multiple files or a folder for more granular storage of changes; and full installations to a hard disk drive (HDD) or USB, which operate in pupmode=12 for immediate writes. For read-only RAM mode without persistence, the pfix=ram boot parameter prevents loading any savefile, ensuring all changes are temporary and discarded on shutdown, ideal for secure or temporary sessions. Pupmode=13, the default for USB frugal installs, buffers changes in RAM and prompts for saving on shutdown or via a desktop icon, balancing performance and durability.[28][29][30] This RAM-based design yields significant performance advantages, particularly on resource-constrained hardware, with applications launching near-instantaneously due to the absence of disk seeks and enabling smooth multitasking even on systems with limited memory. Puppy Linux recommends a minimum of 256 MB of RAM for comfortable operation, though it can function on as little as 128 MB by leveraging efficient layering and optional nocopy modes that avoid duplicating .sfs files in RAM when memory is scarce.[27][29][1] Despite these benefits, limitations arise in handling large files or extensive modifications, as the RAM overlay can fill quickly; workarounds include mounting external volumes via loop devices for oversized data storage, preventing overflow in the tmpfs layer. In modern versions such as those in the 10.0.x series, automatic session saving prompts appear at shutdown in pupmode=13 to mitigate data loss risks from power interruptions, though large savefiles (e.g., over 500 MB) may prolong boot and shutdown times due to compression and extraction overhead.[30][31][29]User Interface and Desktop
Default Environment and Window Manager
Puppy Linux employs Joe's Window Manager (JWM) as its primary window manager, a lightweight X11 solution designed for efficiency on resource-constrained systems. JWM provides customizable panels for task management, a simple menu structure configured via XML files, and support for keyboard-driven navigation, enabling users to control windows and applications without relying heavily on the mouse. This setup contributes to the distribution's minimal footprint, typically consuming under 300 MB of RAM upon boot.[32][33] The desktop environment traditionally integrates ROX-Filer as the file manager and desktop handler in many variants, managing icons and providing a straightforward, icon-based interface for file operations. ROX-Filer's configuration allows for easy placement of desktop icons and supports drag-and-drop functionality, maintaining a clean and functional layout without the overhead of full desktop environments like GNOME or KDE. Some modern variants, such as TrixiePup64, use SpaceFM instead. Menus are generated dynamically through JWM's configuration files, offering categorized access to applications and system tools in a hierarchical structure.[33][34] Aesthetically, Puppy Linux defaults to a gradient-gray theme across JWM windows, panels, and GTK2 elements, with a simple background image and icon sets like "Original" or "FlatOrange" for desktop elements. Users can adjust color schemes and themes via graphical tools accessible from the Desktop menu, such as the JWM configuration utility and Chtheme for GTK adjustments, which apply changes by editing files like/root/.jwmrc and /root/.gtkrc-2.0 without requiring a full system restart. These tools facilitate quick theming modifications, supporting a range of pre-installed options for visual customization.[35]
The environment emphasizes accessibility for legacy hardware, with JWM's low resource demands ensuring compatibility with low-resolution displays (as low as 800x600) and older graphics hardware, while keyboard shortcuts—such as Alt+Tab for window switching and configurable bindings for menu access—support navigation for users with motor impairments or those preferring text-based input. This design prioritizes usability on systems with limited capabilities, aligning with Puppy Linux's focus on frugal computing. Barry Kauler's EasyOS project, active as of November 2025 and based on Devuan, retains JWM and ROX-Filer for consistency.[32][1][36]
Included Applications and Customization
Puppy Linux distributions include a curated selection of lightweight applications optimized for minimal resource consumption, enabling efficient operation on older hardware. Representative examples from recent builds encompass web browsers such as Firefox ESR, which provides secure browsing capabilities, and in some variants, Pale Moon as an alternative for enhanced privacy and speed.[37][34] For productivity, lightweight options like AbiWord and Gnumeric are commonly available, along with graphics tools such as GIMP and media players like Audacious, often installed via the package manager to suit user needs while keeping the base ISO under 400 MB.[1] These applications form a balanced default bundle, prioritizing functionality over bloat. Customization in Puppy Linux emphasizes user-friendly tools that allow personalization without compromising system stability. The Puppy Package Manager (PPM) serves as a graphical interface for installing, updating, and removing packages, supporting both legacy PET files and integration with Debian repositories via Apt for broader software access.[37][34] Theming and menu editing are facilitated through script-based configurations, particularly for the JWM window manager, where users can modify desktop layouts, icons, and shortcuts directly via editable configuration files without requiring elevated privileges, as the system operates under a single-user model by default. Puppy supports multiple persistence profiles via separate save files selectable at boot, allowing basic configuration separation for shared use without full multi-user account support.[37][38] At boot time, users can select session types such as live mode for temporary use or frugal installations for persistent setups on removable media, providing flexibility in deployment without complex setup procedures.[38] In 2025 releases, Puppy Linux incorporates modern enhancements like PipeWire for low-latency audio processing, replacing older sound servers to improve multimedia performance across applications. Select variants, such as TrixiePup64, experiment with Wayland as a display server protocol in dedicated builds, offering smoother compositing and compatibility with X11 via XWayland for transitional support.[37][34]Package and Distribution Management
Pet Package System
The Pet package system in Puppy Linux utilizes self-contained .pet files as the primary format for distributing and installing software. These files are compressed tar archives (tar.gz) with an appended 32-byte MD5 checksum for verifying integrity during transfer and installation.[39] Each .pet package typically includes application binaries, necessary libraries, configuration files, desktop integration elements like .desktop files, and a metadata 'specs' file that describes the package for management tools.[39] Package sizes vary but commonly range from a few megabytes for lightweight tools to around 100 MB for more comprehensive applications, such as multimedia suites.[40] Installation of .pet packages is designed for simplicity, often requiring only a double-click on the file within the ROX-Filer or another file manager, which invokes the underlying package handler to extract and overlay the contents onto the running system via Puppy's union filesystem.[41] In frugal installations, where the system operates primarily from RAM, .pet files integrate changes into the persistent save file (pupsave), necessitating at least three times the package size in available save space to accommodate extraction and union layering.[40] Full hard drive installations bypass the save file requirement, applying changes directly to the filesystem.[40] The Puppy Package Manager (PPM), a graphical tool accessible via the Setup menu or theppm command, serves as the central interface for managing .pet packages.[42] It enables users to search official repositories using keywords or wildcards, download packages, and handle basic dependency resolution, though .pet files are engineered to minimize external dependencies for standalone functionality.[42] PPM maintains a standardized database of installed packages in /root/.packages, supports menu integration for new applications, and includes features like post-installation integrity checks and optional space optimization by trimming unnecessary files.[42] Updates to installed .pet packages can be performed through PPM by selecting available newer versions from repositories.[42]
For modular system extensions and larger updates, Puppy Linux incorporates SquashFS (SFS) files as read-only compressed overlays that layer atop the base system at boot, allowing additions like kernel modules or development environments without reinstalling the core distribution.[43] These SFS layers integrate seamlessly with the union filesystem, preserving the original system intact.[1] Rollback of changes, including those from .pet or SFS additions, is facilitated by the frugal model's session management: users can boot without committing to the pupsave file or delete it entirely to restore a pristine state.[44]
Key advantages of the Pet package system include its ease of reversal, as installations do not permanently alter the base filesystem until explicitly saved, and the ability to perform many operations without additional privilege escalation beyond Puppy's default root user environment.[39] This approach supports rapid experimentation and deployment on resource-constrained hardware, with .pet files often installable in seconds due to their compressed, self-extracting nature.[41] The system also briefly accommodates compatibility extensions for upstream packages from distributions like Debian, though the native .pet format remains the focus for Puppy-specific optimizations.[42]
Integration with Upstream Repositories
Puppy Linux variants based on Debian, such as BookwormPup64 derived from Debian 12 "Bookworm," integrate with upstream repositories through the APT package manager, augmented by Puppy-specific wrappers to ensure compatibility with the distribution's lightweight, RAM-based filesystem structure. These wrappers handle dependency resolution and installation paths to prevent conflicts with Puppy's native PET package system, allowing users to install and update software directly from Debian's official mirrors while maintaining the core system's minimal footprint.[45] Similarly, Ubuntu-based variants like NoblePup64, built from Ubuntu 24.04 "Noble Numbat" binaries, and FossaPup64 from Ubuntu 20.04 "Focal Fossa," employ APT with analogous wrappers for seamless access to Ubuntu repositories, enabling the installation of thousands of packages without requiring full system reconfiguration. As of November 2025, some community variants like PuppEX Trixie64 integrate with Debian 13 "Trixie" repositories.[46][47] For Slackware-based editions, such as Slacko Puppy, integration occurs via Slackware's pkgtools, which manage TXZ package formats natively, providing binary compatibility with Slackware 14.x repositories through tools like installpkg and upgradepkg; newer variants like S15Pup support Slackware 15.0.[48][49] To enhance compatibility across different package ecosystems, Puppy Linux employs conversion tools such as deb2pet and rpm2pet, which transform upstream .deb files from Debian/Ubuntu or .rpm files from other distributions into the native .pet format, allowing selective integration without altering the core architecture.[50] These scripts extract contents, resolve basic dependencies, and repackage them for Puppy's SquashFS-based modules, facilitating offline use through repo mirroring utilities that synchronize upstream repositories to local directories for environments with limited internet access.[51] This approach bridges the gap between Puppy's proprietary PET handling and broader Linux ecosystems, though it requires manual intervention for complex dependencies. A primary challenge in upstream integration is managing GNU C Library (glibc) versions, as mismatches can destabilize applications; for instance, BookwormPup64 incorporates glibc 2.36 from Debian 12 as its base, while in older variants like Fossapup64 (with glibc 2.31), developers implement selective upgrades to higher versions such as 2.36 for critical components to support modern software while preserving system lightness and avoiding full recompilation.[52] Newer bases like Debian 13 "Trixie" use glibc 2.41, presenting ongoing compatibility considerations.[53] Solutions include compatibility layers that shim older glibc calls during PET conversions and rigorous testing of upstream packages to exclude those demanding incompatible library features, aiming to keep ISO sizes minimal though Debian/Ubuntu-based variants like BookwormPup64 10.0.12 measure around 791 MB due to included features and modern compatibility.[54][55] In the 10.0.x series, such as BookwormPup64 10.0.12, enhancements to the Synaptic GUI package manager have streamlined upstream browsing and installation, providing a user-friendly interface to search, select, and fetch Debian packages directly without expanding the core distribution's footprint, thus improving accessibility for non-technical users while adhering to Puppy's frugal design principles.[1]Building and Derivatives
Woof-CE Build Tools
Woof-CE, or Woof Community Edition, is an open-source collection of build scripts designed to construct Puppy Linux distributions from scratch, forked from Barry Kauler's original Woof2 system in November 2013 following his retirement from active development.[56][2] This fork enables the creation of customized Puppy Linux images by leveraging binary packages from upstream distributions, ensuring compatibility and lightweight design while allowing community enhancements.[57] Hosted on GitHub, Woof-CE facilitates automated builds and has been instrumental in producing official and derivative Puppy variants since its inception.[56] The build process begins with selecting a base distribution, such as Debian or Ubuntu, and configuring package selections through PET (Puppy's native format) or DEB lists to include essential applications and drivers.[57] Standard Linux tools like debootstrap for base system extraction and xorriso for ISO creation are then employed to compile the distribution, supporting both frugal installations (running directly from read-only media with optional persistence) and full installations to disk.[58] The workflow requires a compatible host environment, such as a recent Puppy Linux variant with the devx development module and at least 10 GB of free space, and proceeds through stages of downloading repositories, resolving dependencies, and assembling the final image.[57] Woof-CE supports multiple architectures, including x86, x86_64, and ARM, allowing builds for diverse hardware targets.[57] Key scripts drive the automation, withmerge2out serving as the initial configurator that integrates core code from woof-code, prebuilt binaries from woof-arch, and distro-specific files from woof-distro to generate a tailored build environment.[56] Subsequent scripts, such as 0setup for environment preparation, 1download for fetching packages, 2createpackages for compatibility conversion, and 3builddistro for final assembly, streamline the process into a cohesive ISO output.[57] Additional utilities like kernel-kit handle kernel compilation and patching, while initrd-progs manage initial ramdisk generation.[59]
Maintenance of Woof-CE occurs through collaborative contributions on GitHub, where developers submit patches and pull requests to address compatibility issues and incorporate updates.[57] Ongoing efforts have included enhancements to the kernel-kit for seamless integration of Linux kernel 6.1, an LTS release, with support up to version 6.1.158 as of November 2025, enabling more robust support for modern hardware in Puppy builds.[60] These updates ensure Woof-CE remains adaptable to evolving upstream changes, such as those in Debian and Ubuntu repositories.[58]
Creating Custom Variants
Creating custom variants of Puppy Linux typically begins with forking or cloning the Woof-CE build system from its official GitHub repository.[56] Users then run themerge2out script to configure the build environment, selecting the host and target architecture along with a compatible upstream distribution such as Ubuntu or Slackware.[57] This sets up the necessary directories in woof-out-*, where subsequent steps like ./0setup for initialization, ./1download for fetching packages, ./2createpackages for compiling or customizing applications, and ./3builddistro-Z for generating the final ISO occur.[57]
To incorporate custom applications or modifications, developers edit files in the woof-distro or woof-code directories, such as compatibility profiles that specify package sources and dependencies for adding software like specialized drivers.[56] For instance, hardware-specific drivers can be integrated by adjusting kernel configurations via the included kernel-kit or by including additional packages during the createpackages phase, ensuring compatibility with target devices.[57] Testing the resulting ISO is essential and commonly performed in virtual environments like QEMU or other VMs to verify bootability and functionality across architectures.[56]
Tools like SFS Builder facilitate modular additions by packaging custom components into SquashFS (SFS) files, which can be layered onto the base system without rebuilding the entire distribution.[1] Remastering scripts, such as those provided in Woofy, allow users to start from an existing Puppy ISO, apply changes like theme adjustments or application integrations, and output a new customized image directly.[61] Documentation for these processes is available through the Woof-CE repository and related build guides, emphasizing best practices like using a host system with at least 10 GB of storage and starting from a Woof-CE-built Puppy for reliability.[56]
Common customizations include thematic adaptations for specific use cases, such as educational interfaces with simplified desktops, and embedding streamlined versions for resource-constrained environments.[1] Legal aspects of redistribution are governed by the Creative Commons CC0 dedication applied to Woof-CE components, placing them in the public domain and permitting free modification and distribution provided upstream licenses are respected.[1]
Variants
Official Releases
The official releases of Puppy Linux represent the endorsed variants maintained by the Puppy Linux Team, emphasizing core principles such as frugality, portability, and ease of use while adapting to different base distributions for varied package management and hardware support.[1] As of November 2025, the current lineup includes BookwormPup64 10.0.12, FossaPup64 9.5, S15Pup64 22.12, and NoblePup32 24.04, each built using the Woof-CE tools to ensure compatibility with modern hardware and security standards.[19][62][63] These releases maintain ISO sizes between 300-500 MB, allowing for quick downloads and boots from USB or CD, with 64-bit architectures dominant since 2015 to leverage contemporary processor capabilities, while 32-bit support persists in NoblePup32 for legacy systems.[64][17] BookwormPup64 10.0.12 is based on Debian 12 (Bookworm) and prioritizes stability through features like OverLayFS for file system management, enabling seamless updates without altering the host system; it integrates the APT package manager for access to Debian repositories, making it suitable for users seeking a reliable, long-term environment.[19] FossaPup64 9.5 derives from Ubuntu 20.04 (Focal Fossa), offering long-term support with a focus on minimalism and broad hardware compatibility, utilizing APT for package handling while preserving Puppy's lightweight footprint for older or resource-constrained machines.[65] S15Pup64 22.12 uses Slackware 15.0 as its base, emphasizing minimalism and simplicity in configuration, with slackpkg for package management to align with Slackware's conservative approach, ideal for users preferring a stripped-down, stable setup without unnecessary dependencies.[62] NoblePup32 24.04 combines elements of Ubuntu 24.04 and Debian for 32-bit systems, focusing on stability and providing a bridge for older hardware, with APT integration to facilitate package installations while upholding Puppy's savefile and frugal installation options.[63] Maintenance of these releases is coordinated by the Puppy Linux Team through platforms like the official forum, SourceForge, and the Woof-CE GitHub repository, with biannual security updates and point releases to address vulnerabilities and incorporate kernel improvements.[1][66] Each variant includes developer extensions (devx) and kernel sources for customization, ensuring adherence to Puppy's ethos of accessibility and modularity across its family tree.[67]| Release | Base Distribution | Architecture | Key Traits | Package Manager | ISO Size (approx.) |
|---|---|---|---|---|---|
| BookwormPup64 10.0.12 | Debian 12 | 64-bit | Stability, OverLayFS | APT | 400 MB |
| FossaPup64 9.5 | Ubuntu 20.04 | 64-bit | Long-term support, minimalism | APT | 350 MB |
| S15Pup64 22.12 | Slackware 15.0 | 64-bit | Minimalism, simplicity | slackpkg | 460 MB |
| NoblePup32 24.04 | Ubuntu 24.04 + Debian | 32-bit | Stability for legacy hardware | APT | 300 MB |