Add pika-os.md

2025-08-30 21:20:07 +00:00 · 2025-08-30 21:20:07 +00:00 · e8c224132e
commit e8c224132e
parent d3ab2daeb9
1 changed files with 698 additions and 0 deletions
--- a/pika-os.md
+++ b/pika-os.md
@ -0,0 +1,698 @@
+# PikaOS OSTree Implementation Breakdown
+
+## Project Overview
+
+PikaOS is a gaming/optimization-focused Linux distribution that emphasizes ease of use and high compatibility. Built on a Debian base but with cherry picked and custom compiled packages ensures that Pika is stable whilst being bang up to date! PikaOS is a user-friendly, highly optimized and updated GNU/Linux® leading-edge distribution based on Debian®. It uses Debian Sid sources with a whitelist of Debian experimental sources, making it a unique gaming-focused distribution that combines bleeding-edge packages with immutable system management.
+
+**Note**: The pkg-pikman-update-manager and pika-builder repositories were archived by the owner on Nov 14, 2024. They are now read-only. This suggests PikaOS may have evolved beyond OSTree or moved to different update mechanisms.
+
+## Repository Structure
+
+Based on the available information and archived repositories, here's the inferred PikaOS OSTree infrastructure:
+
+```
+PikaOS OSTree Infrastructure:
+├── pika-base-debian-container/                # Base system container
+│   ├── Dockerfile                            # Container build definition
+│   ├── rootfs/                               # Base rootfs content
+│   │   ├── etc/
+│   │   │   ├── pika-release                  # PikaOS version info
+│   │   │   ├── apt/sources.list.d/           # Debian sid + experimental
+│   │   │   └── gaming-optimizations.conf    # Gaming-specific configs
+│   │   ├── usr/
+│   │   │   ├── share/pika/                   # PikaOS-specific data
+│   │   │   └── bin/gaming-setup              # Gaming environment setup
+│   │   └── var/lib/pika/                     # PikaOS state data
+│   └── build-scripts/
+│       ├── gaming-packages.sh                # Gaming package installation
+│       └── optimization-tweaks.sh            # Performance optimizations
+├── pkg-pikman-update-manager/ (ARCHIVED)     # Update management system
+│   ├── src/
+│   │   ├── pikman-update-manager.py          # Main update daemon
+│   │   ├── pikman-gui.py                     # GUI update interface
+│   │   ├── ostree-integration.py             # OSTree backend
+│   │   ├── gaming-update-policies.py         # Gaming-specific update logic
+│   │   └── flatpak-gaming-integration.py    # Gaming app management
+│   ├── data/
+│   │   ├── pikman-update-manager.conf        # Update manager configuration
+│   │   ├── gaming-remotes.conf               # Gaming-focused OSTree remotes
+│   │   └── systemd/
+│   │       ├── pikman-update-manager.service
+│   │       └── pikman-gaming-optimizer.service
+│   ├── cli/
+│   │   └── pikman-cli.py                     # Command-line interface
+│   └── tests/
+│       ├── test-gaming-updates.py
+│       └── test-graphics-driver-updates.py
+├── pika-builder/ (ARCHIVED)                  # Image building system
+│   ├── recipes/
+│   │   ├── gaming-ostree.yaml                # Gaming-optimized OSTree image
+│   │   ├── minimal-ostree.yaml               # Minimal OSTree variant
+│   │   └── development-ostree.yaml           # Development OSTree image
+│   ├── scripts/
+│   │   ├── build-gaming-ostree.sh            # Gaming image builder
+│   │   ├── optimize-for-gaming.sh            # Gaming optimizations
+│   │   └── package-gaming-bundle.sh          # Gaming package bundling
+│   ├── configs/
+│   │   ├── gaming-packages.list              # Gaming package definitions
+│   │   ├── graphics-drivers.list             # Graphics driver packages
+│   │   └── performance-tweaks.list           # Performance optimization packages
+│   └── ostree/
+│       ├── gaming-ostree.conf                # Gaming OSTree configuration
+│       └── remotes/
+│           ├── pika-gaming.conf              # Gaming-focused remote
+│           └── pika-stable.conf              # Stable release remote
+└── pika-ostree-tools/                        # OSTree utilities
+    ├── gaming-update-generator/              # Gaming-specific update tools
+    ├── graphics-driver-manager/              # Driver update management
+    └── performance-profiler/                 # Gaming performance analysis
+```
+
+## Gaming-Focused OSTree Implementation
+
+### 1. **Gaming-Optimized Update Strategy**
+
+#### Gaming-Aware Update Scheduling
+```python
+# pikman-update-manager gaming logic
+class GamingUpdateScheduler:
+    def __init__(self):
+        self.gaming_session_monitor = GamingSessionMonitor()
+        self.graphics_driver_manager = GraphicsDriverManager()
+        
+    def should_apply_update(self, update_info):
+        # Never update during active gaming sessions
+        if self.gaming_session_monitor.is_game_running():
+            self.log_info("Deferring update - game session active")
+            return False
+            
+        # Check if update affects graphics drivers
+        if update_info.affects_graphics_drivers():
+            if self.graphics_driver_manager.requires_reboot():
+                return self.schedule_during_maintenance_window()
+                
+        return True
+        
+    def get_gaming_maintenance_window(self):
+        # Default: 3 AM - 6 AM when gamers least likely to be active
+        return ("03:00", "06:00")
+```
+
+### 2. **Pikman Package Manager Integration**
+
+Another one of our innovative features is our package manager, pikman, with its apx, apt and flatpak support. This allows you to easily install packages from other distributions without compromising your system's stability.
+
+#### Multi-Backend Package Management
+```python
+# pikman integration with OSTree
+class PikmanOSTreeManager:
+    def __init__(self):
+        self.apt_backend = AptBackend()
+        self.flatpak_backend = FlatpakBackend()
+        self.apx_backend = ApxContainerBackend()
+        self.ostree_repo = OSTreeRepository()
+        
+    def install_gaming_package(self, package_name, backend_preference=None):
+        """Install package using appropriate backend while preserving OSTree"""
+        
+        if backend_preference == "ostree":
+            # Layer package on OSTree deployment
+            return self.ostree_layer_package(package_name)
+        elif backend_preference == "flatpak":
+            # Install as Flatpak (preferred for gaming apps)
+            return self.flatpak_backend.install(package_name)
+        elif backend_preference == "apx":
+            # Install in container environment
+            return self.apx_backend.install_in_container(package_name)
+        else:
+            # Auto-select best backend for gaming
+            return self.auto_select_backend(package_name)
+            
+    def auto_select_backend(self, package_name):
+        """Gaming-optimized backend selection"""
+        if package_name in GAMING_APPS:
+            return self.flatpak_backend.install(package_name)
+        elif package_name in GRAPHICS_DRIVERS:
+            return self.ostree_layer_package(package_name)
+        elif package_name in DEV_TOOLS:
+            return self.apx_backend.install_in_container(package_name)
+        else:
+            return self.flatpak_backend.install(package_name)
+```
+
+### 3. **Gaming-Specific OSTree Remotes**
+
+#### Remote Configuration
+```ini
+# /etc/ostree/remotes.d/pika-gaming.conf
+[remote "pika-gaming"]
+url=https://ostree.pika-os.com/gaming
+gpg-verify=true
+gpg-verify-summary=true
+
+[remote "pika-stable"]  
+url=https://ostree.pika-os.com/stable
+gpg-verify=true
+gpg-verify-summary=true
+
+[remote "pika-experimental"]
+url=https://ostree.pika-os.com/experimental
+gpg-verify=true
+gpg-verify-summary=false
+```
+
+#### Gaming Remote Management
+```python
+# Gaming-focused remote management
+class PikaOSTreeRemotes:
+    def __init__(self):
+        self.gaming_remote = "pika-gaming"
+        self.stable_remote = "pika-stable"
+        self.experimental_remote = "pika-experimental"
+        
+    def get_gaming_updates(self):
+        """Check for gaming-focused updates"""
+        updates = []
+        
+        # Check graphics driver updates
+        driver_updates = self.check_graphics_driver_updates()
+        if driver_updates:
+            updates.extend(driver_updates)
+            
+        # Check game engine updates (Steam, Wine, etc.)
+        engine_updates = self.check_game_engine_updates()
+        if engine_updates:
+            updates.extend(engine_updates)
+            
+        # Check performance optimization updates
+        perf_updates = self.check_performance_updates()
+        if perf_updates:
+            updates.extend(perf_updates)
+            
+        return updates
+```
+
+## Gaming-Optimized Features
+
+### 1. **Graphics Driver Management**
+
+#### Dynamic Graphics Driver Updates
+```python
+# Graphics driver handling in OSTree context
+class GraphicsDriverManager:
+    def __init__(self, ostree_repo):
+        self.ostree_repo = ostree_repo
+        self.nvidia_support = NvidiaDriverSupport()
+        self.amd_support = AMDDriverSupport()
+        
+    def update_graphics_drivers(self, target_commit):
+        """Update graphics drivers while maintaining OSTree immutability"""
+        
+        # Detect current graphics hardware
+        gpu_info = self.detect_gpu_hardware()
+        
+        if gpu_info.vendor == "nvidia":
+            return self.nvidia_support.update_in_ostree(target_commit)
+        elif gpu_info.vendor == "amd":
+            return self.amd_support.update_in_ostree(target_commit)
+        else:
+            # Intel or other - use mesa
+            return self.update_mesa_drivers(target_commit)
+            
+    def nvidia_support.update_in_ostree(self, commit):
+        """Handle NVIDIA driver updates in OSTree"""
+        # Create temporary overlay for driver installation
+        overlay = self.ostree_repo.create_overlay(commit)
+        
+        # Install NVIDIA drivers in overlay
+        self.install_nvidia_drivers(overlay)
+        
+        # Commit overlay as new OSTree deployment
+        new_commit = self.ostree_repo.commit_overlay(overlay, 
+                                                    "Updated NVIDIA drivers")
+        return new_commit
+```
+
+### 2. **Gaming Performance Monitoring**
+
+#### Performance-Aware Updates
+```python
+# Gaming performance impact assessment
+class GamingPerformanceMonitor:
+    def __init__(self):
+        self.fps_monitor = FPSMonitor()
+        self.latency_monitor = LatencyMonitor()
+        self.gpu_utilization = GPUUtilizationMonitor()
+        
+    def assess_update_impact(self, proposed_update):
+        """Assess if update will impact gaming performance"""
+        
+        impact_score = 0
+        
+        # Check if update affects graphics stack
+        if proposed_update.affects_graphics_stack():
+            impact_score += 50  # High impact
+            
+        # Check if update affects kernel
+        if proposed_update.affects_kernel():
+            impact_score += 30  # Medium impact
+            
+        # Check if update affects gaming libraries
+        if proposed_update.affects_gaming_libraries():
+            impact_score += 20  # Low-medium impact
+            
+        return GamingImpactAssessment(impact_score, proposed_update)
+        
+    def recommend_update_strategy(self, assessment):
+        if assessment.impact_score > 70:
+            return "SCHEDULE_MAINTENANCE_WINDOW"
+        elif assessment.impact_score > 40:
+            return "PROMPT_USER_BEFORE_APPLY"
+        else:
+            return "APPLY_AUTOMATICALLY"
+```
+
+### 3. **Dual-Mode Gaming Support**
+
+#### Immutable Base + Mutable Gaming Layer
+```python
+# PikaOS gaming layer management
+class PikaGamingLayerManager:
+    def __init__(self, ostree_repo):
+        self.ostree_repo = ostree_repo
+        self.base_gaming_layer = None
+        self.user_gaming_layer = None
+        
+    def create_gaming_environment(self):
+        """Create optimized gaming environment on OSTree base"""
+        
+        # Base immutable gaming layer (Steam, Wine, etc.)
+        self.base_gaming_layer = self.ostree_repo.create_layer([
+            "steam-installer",
+            "wine-staging", 
+            "lutris",
+            "gamemode",
+            "mangohud",
+            "vkbasalt"
+        ])
+        
+        # User-specific gaming layer (games, saves, configs)
+        self.user_gaming_layer = self.create_user_gaming_overlay()
+        
+        return self.combine_layers([
+            self.ostree_repo.get_base_commit(),
+            self.base_gaming_layer,
+            self.user_gaming_layer
+        ])
+```
+
+### 4. **Pikman Update Manager GUI**
+
+Pikman Update Manager – A dual-mode (GUI + CLI) update manager. Shows a list of installed remotes and their installation locales System/User However they are immutable, can only be added or removed.
+
+#### GUI Update Interface
+```python
+# Gaming-friendly GUI update manager
+class PikmanUpdateManagerGUI:
+    def __init__(self):
+        self.ostree_backend = OSTreeBackend()
+        self.gaming_detector = GamingSessionDetector()
+        self.ui = self.build_gaming_ui()
+        
+    def build_gaming_ui(self):
+        """Create gaming-optimized update interface"""
+        
+        layout = {
+            "header": {
+                "title": "PikaOS Update Manager",
+                "gaming_status": self.get_gaming_status_widget(),
+                "performance_impact": self.get_performance_impact_widget()
+            },
+            "main": {
+                "available_updates": self.get_updates_list_widget(),
+                "gaming_optimizations": self.get_gaming_opts_widget(),
+                "graphics_drivers": self.get_graphics_driver_widget()
+            },
+            "footer": {
+                "apply_button": self.create_smart_apply_button(),
+                "schedule_button": self.create_schedule_button(),
+                "gaming_mode_toggle": self.create_gaming_mode_toggle()
+            }
+        }
+        
+        return layout
+        
+    def create_smart_apply_button(self):
+        """Context-aware update application"""
+        button = UpdateButton("Apply Updates")
+        
+        button.on_click = lambda: (
+            self.prompt_gaming_session_warning() 
+            if self.gaming_detector.is_game_running()
+            else self.apply_updates_immediately()
+        )
+        
+        return button
+```
+
+## Gaming-Specific Update Policies
+
+### 1. **Gaming Session Awareness**
+
+```python
+# Gaming session detection and update deferral
+class GamingSessionDetector:
+    def __init__(self):
+        self.monitored_processes = [
+            "steam", "lutris", "wine", "proton",
+            "minecraft", "discord", "obs-studio"
+        ]
+        self.gpu_monitor = GPUUsageMonitor()
+        
+    def is_game_running(self):
+        """Detect active gaming sessions"""
+        
+        # Check for gaming processes
+        for process in self.monitored_processes:
+            if self.is_process_running(process):
+                return True
+                
+        # Check GPU utilization (likely gaming if high)
+        if self.gpu_monitor.get_utilization() > 80:
+            return True
+            
+        # Check for fullscreen applications
+        if self.is_fullscreen_app_running():
+            return True
+            
+        return False
+        
+    def get_estimated_session_end(self):
+        """Estimate when gaming session might end"""
+        current_session_length = self.get_current_session_duration()
+        average_session_length = self.get_average_session_length()
+        
+        # Conservative estimate
+        return current_session_length + (average_session_length * 0.5)
+```
+
+### 2. **Graphics Driver Compatibility**
+
+```python
+# Graphics driver management for gaming
+class PikaGraphicsDriverManager:
+    def __init__(self):
+        self.nvidia_manager = NvidiaDriverOSTreeManager()
+        self.amd_manager = AMDDriverOSTreeManager()
+        self.mesa_manager = MesaDriverOSTreeManager()
+        
+    def prepare_graphics_update(self, target_commit):
+        """Prepare graphics drivers for OSTree update"""
+        
+        gpu_type = self.detect_gpu()
+        
+        if gpu_type == "nvidia":
+            # Handle NVIDIA's complex driver installation
+            return self.nvidia_manager.prepare_ostree_layer(target_commit)
+        elif gpu_type == "amd":
+            # AMD open-source driver updates
+            return self.amd_manager.update_amdgpu_stack(target_commit)
+        else:
+            # Intel/Mesa updates
+            return self.mesa_manager.update_mesa_stack(target_commit)
+            
+    def validate_gaming_compatibility(self, new_commit):
+        """Ensure gaming compatibility after graphics updates"""
+        test_results = {
+            "vulkan_support": self.test_vulkan_functionality(),
+            "opengl_support": self.test_opengl_functionality(), 
+            "steam_compatibility": self.test_steam_integration(),
+            "wine_compatibility": self.test_wine_integration()
+        }
+        
+        return all(test_results.values())
+```
+
+### 3. **Performance Optimization Integration**
+
+```python
+# Gaming performance optimization in OSTree context
+class PikaPerformanceOptimizer:
+    def __init__(self):
+        self.cpu_governor = CPUGovernorManager()
+        self.memory_manager = MemoryOptimizer()
+        self.io_scheduler = IOSchedulerOptimizer()
+        
+    def apply_gaming_optimizations(self, ostree_deployment):
+        """Apply gaming optimizations to OSTree deployment"""
+        
+        optimizations = [
+            # CPU optimizations
+            self.cpu_governor.set_performance_mode(),
+            
+            # Memory optimizations  
+            self.memory_manager.configure_gaming_memory(),
+            
+            # I/O optimizations
+            self.io_scheduler.set_gaming_scheduler(),
+            
+            # Graphics optimizations
+            self.configure_graphics_performance(),
+            
+            # Network optimizations for online gaming
+            self.configure_gaming_network_stack()
+        ]
+        
+        return self.commit_optimizations_to_ostree(ostree_deployment, optimizations)
+```
+
+## PikaOS Architecture Innovations
+
+### 1. **Container-Based Base System**
+
+The `pika-base-debian-container` suggests PikaOS uses containerized base systems:
+
+```dockerfile
+# Dockerfile for PikaOS base
+FROM debian:sid
+
+# Install PikaOS-specific gaming optimizations
+RUN apt-get update && apt-get install -y \
+    gaming-meta-packages \
+    pika-gaming-optimizations \
+    custom-kernel-gaming \
+    graphics-drivers-meta
+
+# Configure for OSTree compatibility
+RUN /usr/bin/pika-ostree-prepare
+
+# Gaming-specific configurations
+COPY gaming-configs/ /etc/pika/gaming/
+COPY performance-profiles/ /etc/pika/performance/
+
+# OSTree integration
+RUN ostree-prep-container
+```
+
+### 2. **Hybrid Update Model**
+
+```python
+# PikaOS hybrid update approach
+class PikaHybridUpdateManager:
+    def __init__(self):
+        self.ostree_manager = OSTreeManager()          # Base system
+        self.flatpak_manager = FlatpakManager()        # Gaming apps
+        self.apx_manager = ApxContainerManager()       # Development tools
+        
+    def perform_system_update(self):
+        """Coordinate updates across all package backends"""
+        
+        update_plan = UpdatePlan()
+        
+        # OSTree base system updates
+        ostree_updates = self.ostree_manager.check_updates()
+        update_plan.add_ostree_updates(ostree_updates)
+        
+        # Flatpak gaming application updates
+        flatpak_updates = self.flatpak_manager.check_gaming_updates()
+        update_plan.add_flatpak_updates(flatpak_updates)
+        
+        # Container-based development tool updates
+        apx_updates = self.apx_manager.check_container_updates()
+        update_plan.add_apx_updates(apx_updates)
+        
+        # Execute coordinated update
+        return self.execute_coordinated_update(update_plan)
+```
+
+### 3. **Gaming Application Integration**
+
+```python
+# Gaming application lifecycle management
+class PikaGamingAppManager:
+    def __init__(self):
+        self.steam_integration = SteamOSTreeIntegration()
+        self.lutris_integration = LutrisOSTreeIntegration()
+        self.wine_integration = WineOSTreeIntegration()
+        
+    def install_gaming_environment(self):
+        """Install complete gaming environment on OSTree"""
+        
+        # Create gaming application layer
+        gaming_layer = self.ostree_repo.create_layer("gaming-apps")
+        
+        # Install Steam with OSTree compatibility
+        self.steam_integration.install_to_layer(gaming_layer)
+        
+        # Configure Wine with PikaOS optimizations
+        self.wine_integration.configure_pika_wine(gaming_layer)
+        
+        # Set up Lutris with custom runners
+        self.lutris_integration.setup_pika_runners(gaming_layer)
+        
+        # Commit gaming layer
+        return self.ostree_repo.commit_layer(gaming_layer, 
+                                           "PikaOS Gaming Environment")
+```
+
+## Technical Implementation Details
+
+### 1. **Debian Sid + Experimental Integration**
+
+```yaml
+# PikaOS package source configuration
+pika_sources:
+  debian_sid:
+    url: "http://deb.debian.org/debian"
+    suite: "sid"
+    components: ["main", "contrib", "non-free"]
+    priority: 500
+    
+  debian_experimental:
+    url: "http://deb.debian.org/debian"  
+    suite: "experimental"
+    components: ["main", "contrib", "non-free"]
+    priority: 100  # Lower priority, whitelist only
+    whitelist:
+      - mesa-drivers
+      - nvidia-driver
+      - wine-staging
+      - gaming-performance-tools
+      
+  pika_custom:
+    url: "https://repo.pika-os.com/debian"
+    suite: "pika"
+    components: ["main", "gaming"]
+    priority: 600  # Highest priority for PikaOS packages
+```
+
+### 2. **Gaming Package Bundling**
+
+```bash
+#!/bin/bash
+# build-gaming-ostree.sh
+
+# PikaOS gaming package bundles
+GAMING_ESSENTIAL=(
+    "steam-installer"
+    "wine-staging" 
+    "lutris"
+    "gamemode"
+    "mangohud"
+    "vkbasalt"
+    "gamescope"
+)
+
+GRAPHICS_STACK=(
+    "mesa-vulkan-drivers"
+    "vulkan-tools"
+    "nvidia-driver-libs"  # If NVIDIA detected
+    "amdgpu-pro"          # If AMD detected
+)
+
+PERFORMANCE_TOOLS=(
+    "cpufrequtils"
+    "irqbalance"
+    "preload"
+    "zram-tools"
+    "gaming-kernel-optimizations"
+)
+
+# Build gaming-optimized OSTree commit
+build_gaming_ostree() {
+    local builddir=$1
+    local target_commit=$2
+    
+    # Install gaming packages
+    install_package_list "${GAMING_ESSENTIAL[@]}" "$builddir"
+    install_package_list "${GRAPHICS_STACK[@]}" "$builddir"
+    install_package_list "${PERFORMANCE_TOOLS[@]}" "$builddir"
+    
+    # Apply PikaOS gaming optimizations
+    apply_pika_gaming_tweaks "$builddir"
+    
+    # Configure for OSTree
+    ostree_prepare_rootfs "$builddir"
+    
+    # Commit to OSTree repository
+    ostree commit --tree=dir="$builddir" \
+                  --branch="pika/gaming/amd64" \
+                  --subject="PikaOS Gaming Build $(date)"
+}
+```
+
+## Unique Gaming-Focused Aspects
+
+### 1. **Performance-First Design**
+
+Unlike general-purpose OSTree distributions, PikaOS prioritizes gaming performance:
+
+- **Custom kernel optimizations** for gaming workloads
+- **Graphics driver priority** in update scheduling
+- **Gaming session awareness** to avoid interrupting gameplay
+- **Performance regression testing** for graphics and gaming libraries
+
+### 2. **Multi-Backend Philosophy**
+
+PikaOS's approach of combining OSTree, Flatpak, and container backends provides:
+
+- **OSTree**: Immutable base system and graphics drivers
+- **Flatpak**: Sandboxed gaming applications
+- **APX Containers**: Development tools and compatibility layers
+- **Traditional APT**: Fallback for compatibility
+
+### 3. **Gaming Community Focus**
+
+The distribution appears designed for the gaming community specifically:
+
+- **Out-of-box gaming setup**: Gaming Out of the Box: Setup for pain-free experience
+- **Controller support**: yes, even the most obscure controller drivers — right out of the box
+- **Gaming utilities**: PikaOS Game Utilities is a meta package that installs Steam, Lutris, GOverlay, MangoHud, Wine, Winetricks, vkBasalt, and other gaming-centric tools
+
+## Current Status and Evolution
+
+**Important Note**: The pkg-pikman-update-manager and pika-builder repositories were archived by the owner on Nov 14, 2024, suggesting that PikaOS may have evolved beyond its original OSTree implementation or adopted different update mechanisms.
+
+This could indicate:
+1. **Migration to different technology**: Possibly moved to a different immutable system approach
+2. **Integration consolidation**: OSTree functionality may have been integrated into the main pikman package manager
+3. **Project evolution**: The distribution may have simplified its update architecture
+
+## Legacy and Influence
+
+PikaOS's approach demonstrates how OSTree can be adapted for **gaming-specific use cases**, with innovations in:
+
+- **Performance-aware update scheduling**
+- **Graphics driver management in immutable systems**
+- **Gaming session detection and deferral**
+- **Multi-backend package management integration**
+
+While the specific OSTree implementations appear to be archived, PikaOS's innovations in **gaming-focused immutable systems** provide valuable insights for future gaming-oriented Linux distributions and demonstrate the flexibility of OSTree for specialized use cases beyond traditional desktop and server deployments.
+
+---
+
+## References
+
+1. [PikaOS Base Debian Container](https://github.com/PikaOS-Linux/pika-base-debian-container)
+2. [Pikman Update Manager (Archived)](https://github.com/PikaOS-Linux/pkg-pikman-update-manager)  
+3. [Pika Builder (Archived)](https://github.com/PikaOS-Linux/pika-builder)