diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index e758f3b..0a75a6e 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -90,7 +90,7 @@ Modern computing is inherently networked. Instead of treating networking as an a ### Planned Components 1. **Qt6/QML GUI** - - Full-screen Wayland application + - Full-screen application - Android-like interface design - Desktop-oriented workflow @@ -99,16 +99,10 @@ Modern computing is inherently networked. Instead of treating networking as an a - Minimal resource usage - Touch and mouse support -3. **Spark CLI Tools (C++)** - - System management utilities - - Package management - - Network configuration (WiFi, VPN, etc.) - - GUI launcher - -4. **Bootstrap Utilities (Included)** - - Git for cloning spark CLI - - Sudo for proper privilege elevation - - Busybox for core system utilities and networking +3. **Network Management** + - Qt6 NetworkManager integration + - WiFi configuration UI + - VPN and advanced networking UI ## Security Considerations @@ -121,9 +115,9 @@ Modern computing is inherently networked. Instead of treating networking as an a ## Performance - Fast boot time (seconds, not minutes) -- Low memory footprint (~50MB base system with busybox) +- Low memory footprint (~20MB base init system) - No unnecessary background services -- Efficient init system +- Efficient init system (no external dependencies) ## Portability diff --git a/BUSYBOX_VERIFICATION.md b/BUSYBOX_VERIFICATION.md deleted file mode 100644 index 3fa9b17..0000000 --- a/BUSYBOX_VERIFICATION.md +++ /dev/null @@ -1,133 +0,0 @@ -# BusyBox Verification in SparkOS - -This document demonstrates how SparkOS verifies that BusyBox is being used. - -## Docker Container Verification - -When you run the SparkOS Docker container, it automatically verifies BusyBox installation and functionality: - -```bash -docker run --rm ghcr.io/johndoe6345789/sparkos:latest -``` - -## Expected Output - -The container startup will display comprehensive BusyBox verification: - -``` -SparkOS Docker Test Environment -================================ - -Verifying BusyBox... -------------------- -✓ BusyBox is installed - -BusyBox version: -BusyBox v1.36.1 (Alpine Linux) multi-call binary. - -BusyBox location: -/bin/busybox --rwxr-xr-x 1 root root 1.2M Dec 29 19:00 /bin/busybox - -Shell (/bin/sh) is BusyBox: -lrwxrwxrwx 1 root root 12 Dec 29 19:00 /bin/sh -> /bin/busybox - → /bin/sh is a symlink to: /bin/busybox - -Available BusyBox applets (sample): -[ -[[ -acpid -addgroup -adduser -adjtimex -ar -arch -arp -arping -ash -awk - ... and 300+ total applets - -Networking applets (required for SparkOS): - ✓ udhcpc - ✓ ip - ✓ ifconfig - ✓ ping - ✓ wget - -Verifying SparkOS init binary... --------------------------------- -✓ Init binary exists --rwxr-xr-x 1 root root 18.2K Dec 29 19:00 /sparkos/rootfs/sbin/init - -File type: -/sparkos/rootfs/sbin/init: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked - -Dependencies: - Static binary (no dependencies) - -Root filesystem structure: --------------------------- -total 28 -drwxr-xr-x 7 root root 4096 Dec 29 19:00 . -drwxr-xr-x 1 root root 4096 Dec 29 19:00 .. -drwxr-xr-x 2 root root 4096 Dec 29 19:00 bin -drwxr-xr-x 2 root root 4096 Dec 29 19:00 etc -drwxr-xr-x 3 root root 4096 Dec 29 19:00 home -drwxr-xr-x 2 root root 4096 Dec 29 19:00 sbin -drwxr-xr-x 2 root root 4096 Dec 29 19:00 usr - -================================ -✓ SparkOS is ready for testing! -================================ - -Summary: - - BusyBox: BusyBox v1.36.1 (Alpine Linux) multi-call binary. - - Init: Custom SparkOS init system - - Shell: BusyBox sh (/bin/sh) - - Networking: BusyBox udhcpc, ip, ping, wget - -To test the init system: - docker run --rm /sparkos/rootfs/sbin/init --help -``` - -## What This Proves - -The verification output demonstrates: - -1. **BusyBox is installed**: Shows version and location -2. **Shell is BusyBox**: `/bin/sh` is a symlink to `/bin/busybox` -3. **Multiple utilities available**: 300+ BusyBox applets (commands) -4. **Networking support**: All required networking tools are present (udhcpc, ip, ifconfig, ping, wget) -5. **Custom init system**: SparkOS init binary is statically compiled and ready - -## Key BusyBox Features Used by SparkOS - -- **Shell**: `sh` (BusyBox ash shell) -- **Networking**: - - `udhcpc` - DHCP client for automatic IP configuration - - `ip` / `ifconfig` - Network interface configuration - - `ping` - Network connectivity testing - - `wget` - File downloading -- **Core utilities**: `ls`, `cat`, `mkdir`, `rm`, `cp`, `mount`, etc. -- **System utilities**: Over 300 common Linux commands in a single binary - -## Alpine Linux and BusyBox - -SparkOS uses Alpine Linux as its Docker base image, which includes BusyBox by default. This provides: - -- **Minimal footprint**: Entire system in ~5MB -- **Security**: Minimal attack surface with fewer packages -- **Performance**: Fast startup and low memory usage -- **Completeness**: All essential utilities in one binary - -## Verification in Code - -The verification is performed by `/sparkos/test.sh` which: -1. Checks if `busybox` command is available -2. Displays version information -3. Lists all available applets -4. Verifies critical networking applets -5. Confirms init binary is present and correct - -This ensures that anyone running the SparkOS Docker container can immediately see proof that BusyBox is being used as advertised. diff --git a/INIT_VERIFICATION.md b/INIT_VERIFICATION.md new file mode 100644 index 0000000..61b915d --- /dev/null +++ b/INIT_VERIFICATION.md @@ -0,0 +1,111 @@ +# SparkOS Init System Verification + +This document demonstrates SparkOS's self-contained init system with no external dependencies. + +## Docker Container Verification + +When you run the SparkOS Docker container, it automatically verifies the init system: + +```bash +docker run --rm ghcr.io/johndoe6345789/sparkos:latest +``` + +## Expected Output + +The container startup will display comprehensive init system verification: + +``` +SparkOS Docker Test Environment +================================ + +Verifying SparkOS init binary... +-------------------------------- +✓ Init binary exists +-rwxr-xr-x 1 root root 20.0K Jan 2 00:00 /sparkos/rootfs/sbin/init + +File type: +/sparkos/rootfs/sbin/init: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked + +Dependencies: + Static binary (no dependencies) + +Root filesystem structure: +-------------------------- +total 16 +drwxr-xr-x 5 root root 4096 Jan 2 00:00 . +drwxr-xr-x 1 root root 4096 Jan 2 00:00 .. +drwxr-xr-x 2 root root 4096 Jan 2 00:00 etc +drwxr-xr-x 2 root root 4096 Jan 2 00:00 sbin +drwxr-xr-x 2 root root 4096 Jan 2 00:00 usr + +================================ +✓ SparkOS is ready for testing! +================================ + +Summary: + - Init: Custom SparkOS init system (no external dependencies) + - Architecture: GUI-only, no CLI/shell + - Network: Direct C implementation via ioctl + - Philosophy: Pure GUI experience, network-first + +Note: SparkOS has no CLI tools (no busybox, no shell) + All functionality is provided through the Qt6 GUI + +To test the init system: + docker run --rm /sparkos/rootfs/sbin/init +``` + +## What This Proves + +The verification output demonstrates: + +1. **Self-contained init**: Statically linked binary with no external dependencies +2. **No CLI tools**: No busybox, no shell, no Unix utilities +3. **Minimal footprint**: Only essential files in root filesystem +4. **Pure C implementation**: All functionality (mounting, networking) via system calls + +## Key Init Features + +- **Filesystem mounting**: Direct mount() system calls (no mount binary) +- **Network initialization**: Direct ioctl calls (no ip/ifconfig/udhcpc) +- **Process management**: Built-in SIGCHLD handler for zombie reaping +- **GUI spawning**: Direct execve() of Qt6 GUI application +- **Overlay filesystem**: Immutable base with writable /var overlay + +## SparkOS Philosophy + +SparkOS eliminates traditional Unix layers: + +- **No busybox**: All functionality in init or Qt6 GUI +- **No shell**: Direct kernel-to-GUI communication +- **No CLI tools**: Everything through GUI interface +- **No users/authentication**: Single-user, direct boot to GUI +- **Network-first**: Networking integrated into GUI, not CLI + +## Init System Architecture + +``` +Init Process (PID 1) +├── Mount filesystems (proc, sys, dev, tmp) +├── Setup overlay filesystem (/var) +├── Initialize network interfaces (ioctl) +└── Spawn Qt6 GUI → Respawn on exit +``` + +All operations use direct system calls: +- `mount()` for filesystem mounting +- `mkdir()` for directory creation +- `socket()` + `ioctl()` for network initialization +- `fork()` + `execve()` for GUI spawning +- `waitpid()` for process reaping + +## Verification in Code + +The verification is performed by `/sparkos/test.sh` which: +1. Checks if init binary exists and is executable +2. Verifies it's statically linked (no dependencies) +3. Shows root filesystem structure +4. Confirms the GUI-only architecture + +This ensures that anyone running the SparkOS Docker container can immediately see proof that SparkOS uses a completely self-contained init system with no external dependencies. + diff --git a/README.md b/README.md index a1372b1..25ac16b 100644 --- a/README.md +++ b/README.md @@ -45,12 +45,12 @@ A revolutionary operating system that ditches Unix conventions for a modern, net ## MVP Status The current MVP provides: -- ✅ Custom init system written in C -- ✅ Working busybox shell environment +- ✅ Custom init system written in C (no external dependencies) +- ✅ GUI-only architecture (no CLI/shell) - ✅ dd-able AMD64 image creation scripts - ✅ Minimal root filesystem structure - ✅ Build system (Makefile) -- ✅ Wired networking configuration with DHCP +- ✅ Direct network initialization via C ioctl - ✅ DNS configuration with public fallback servers - ✅ Docker container for testing - ✅ Automated builds and publishing to GHCR @@ -102,8 +102,8 @@ The UEFI-bootable disk image includes: - ✅ **UEFI boot support** with GRUB bootloader - ✅ **GPT partition table** with ESP (EFI System Partition) - ✅ **Linux kernel** ready to boot -- ✅ **SparkOS init system** and busybox utilities -- ✅ **Ready to boot** - No additional setup required +- ✅ **SparkOS init system** (completely self-contained, no external dependencies) +- ✅ **Ready to boot** - Direct to Qt6 GUI, no CLI ### Using Pre-built Binary Package @@ -156,14 +156,12 @@ The Docker image includes: - Pre-built init system binary - Minimal root filesystem structure - Test environment for validation -- **BusyBox shell and utilities**: Alpine Linux base provides BusyBox (verified on startup) +- **No CLI tools**: Pure GUI-only architecture - **Multi-architecture support**: Available for both AMD64 (x86_64) and ARM64 (aarch64) architectures When you run the Docker image, it automatically verifies: -- BusyBox version and installation -- Available BusyBox applets (sh, ls, cat, etc.) -- Required networking tools (udhcpc, ip, ping, wget) -- Custom init system binary +- Custom init system binary (statically linked, no dependencies) +- Root filesystem structure Images are automatically built and published to [GitHub Container Registry](https://github.com/johndoe6345789/SparkOS/pkgs/container/sparkos) on every push to main branch. @@ -220,7 +218,7 @@ This creates a complete UEFI-bootable image with: - EFI System Partition (ESP) with FAT32 - GRUB UEFI bootloader - Linux kernel -- SparkOS init system and busybox +- SparkOS init system (no external dependencies) **Traditional Method (Requires Root):** @@ -286,31 +284,31 @@ SparkOS/ ### Init System SparkOS uses a custom init system (`/sbin/init`) that: -- Mounts essential filesystems (proc, sys, dev, tmp) -- Initializes wired networking via DHCP -- Spawns a busybox sh login shell +- Mounts essential filesystems (proc, sys, dev, tmp) via direct system calls +- Initializes network interfaces via direct C ioctl calls +- Spawns Qt6 GUI application directly - Handles process reaping -- Respawns shell on exit +- Respawns GUI on exit +- **No external dependencies**: Completely self-contained ### Root Filesystem -Follows the Filesystem Hierarchy Standard (FHS): -- `/bin`, `/sbin`: Essential binaries -- `/etc`: System configuration +Minimal filesystem structure for GUI-only OS: +- `/sbin`: Init binary only +- `/etc`: Minimal system configuration - `/proc`, `/sys`, `/dev`: Kernel interfaces - `/tmp`: Temporary files -- `/usr`: User programs and libraries -- `/var`: Variable data -- `/root`: Root user home -- `/home`: User home directories +- `/usr`: Qt6 GUI application and libraries +- `/var`: Variable data (overlay mount) +- `/root`: Root home ### Networking -SparkOS provides wired networking for initial bootstrap: -- **DHCP**: Automatic IP configuration via busybox udhcpc +SparkOS provides network initialization through direct C code: +- **Interface Management**: Direct ioctl calls to bring up network interfaces - **DNS**: Fallback to public DNS servers (8.8.8.8, 8.8.4.4, 1.1.1.1, 1.0.0.1) -- **Interface**: Primary wired interface (eth0) configured automatically -- **WiFi**: Will be configured later via spark CLI after installation +- **DHCP**: Managed by Qt6 NetworkManager in GUI +- **WiFi**: Configured through Qt6 GUI ## Development @@ -418,63 +416,31 @@ make clean make help ``` -### Adding Binaries to Root Filesystem +### Adding Components to Root Filesystem -To create a fully functional system, you need to populate the rootfs with binaries: +To create a fully functional bootable system: ```bash -# Required binaries (statically linked recommended) -# 1. Busybox - provides shell and most utilities including networking -cp /path/to/busybox rootfs/bin/ +# Required components: +# 1. Qt6 GUI application - Build with make gui +# 2. Qt6 libraries - Copy Qt6 runtime libraries to rootfs/usr/lib +# 3. Linux kernel - Include kernel binary for bootloader -# 2. Git - for cloning spark CLI -cp /path/to/git rootfs/bin/ -# Note: If git is dynamically linked, you'll need to copy its libraries too +# Qt6 GUI is built and installed via: +make gui +make install # Installs to rootfs/usr/bin/sparkos-gui -# 3. Sudo - for privilege elevation -cp /path/to/sudo rootfs/bin/ - -# Create busybox symlinks for common utilities -cd rootfs/bin -for cmd in sh ls cat mkdir rm cp mount umount chmod chown ln \ - ip ifconfig ping wget udhcpc; do - ln -sf busybox $cmd -done -cd ../.. - -# If using dynamically linked binaries, copy required libraries -ldd rootfs/bin/busybox # Check dependencies -ldd rootfs/bin/git # Check dependencies -ldd rootfs/bin/sudo # Check dependencies -# Copy libraries to rootfs/lib or rootfs/lib64 as needed -``` - -### Testing Network Connectivity - -Once booted, you can test the network: - -```bash -# Check interface status -ip addr show - -# Test DNS resolution -ping -c 3 google.com - -# Test direct IP connectivity -ping -c 3 8.8.8.8 - -# Download a file -wget http://example.com/file +# Note: Qt6 must be compiled with linuxfb support for framebuffer rendering ``` ## Future Roadmap -- [ ] Qt6/QML full screen GUI +- [ ] Qt6/QML full screen GUI implementation - [ ] Wayland compositor integration -- [ ] C++ CLI tools (spark command) -- [ ] Package management via spark CLI -- [ ] WiFi configuration via spark CLI -- [ ] Advanced network configuration +- [ ] Network management via Qt6 NetworkManager +- [ ] WiFi configuration through GUI +- [ ] Advanced network configuration UI +- [ ] System settings and configuration UI ## Contributing @@ -482,6 +448,7 @@ Contributions are welcome! This is an early-stage project focused on: 1. Maintaining minimal footprint 2. Clean, readable code 3. Proper documentation +4. GUI-only architecture (no CLI/shell) ## License @@ -490,26 +457,26 @@ See LICENSE file for details. ## Notes This is an MVP implementation. The system currently provides: -- Basic init system with network initialization -- Shell environment +- Custom init system with direct network initialization +- GUI-only architecture (no CLI/shell) - Build infrastructure - Image creation tooling -- Wired networking configuration +- Self-contained init with no external dependencies To create a fully bootable system, you'll also need: -- Linux kernel binary (`vmlinuz`) -- Essential system binaries: busybox, git, sudo -- Required libraries (if using dynamically linked binaries) +- Linux kernel binary (`vmlinuz`) with framebuffer and networking support +- Qt6 GUI application (sparkos-gui) +- Qt6 runtime libraries - Bootloader installation (handled by scripts) Minimum System Requirements: -- Kernel: Linux kernel with networking support -- Init: Custom SparkOS init (included) -- Shell: Busybox with networking utilities (udhcpc, ip/ifconfig, ping, wget) -- VCS: Git (for installing spark CLI) -- Security: Sudo (for privilege elevation) +- Kernel: Linux kernel with framebuffer and networking support +- Init: Custom SparkOS init (included, no dependencies) +- GUI: Qt6 application with linuxfb platform support +- Libraries: Qt6 runtime libraries for GUI -After bootstrap: -1. Use wired network to clone spark CLI via git -2. Use spark CLI to configure WiFi and other system features -3. Install additional packages as needed via spark CLI +System Philosophy: +- **No CLI tools**: Everything through Qt6 GUI +- **No shell**: Direct kernel-to-GUI communication +- **No busybox**: Self-contained init system +- **Network-first**: Networking integrated into GUI diff --git a/config/RELEASE_README.md b/config/RELEASE_README.md index a7339d2..19e14f9 100644 --- a/config/RELEASE_README.md +++ b/config/RELEASE_README.md @@ -42,8 +42,8 @@ Follow the instructions in README.md to create a complete bootable system. ## System Requirements -- Linux system with kernel 3.x or later -- Busybox for shell and utilities +- Linux system with kernel 3.x or later with framebuffer support +- Qt6 runtime libraries for GUI - For building: GCC compiler, Make ## Documentation diff --git a/config/build.conf b/config/build.conf index ff49c18..96638e7 100644 --- a/config/build.conf +++ b/config/build.conf @@ -16,9 +16,6 @@ BOOTLOADER=syslinux # Init system INIT=sparkos-init -# Default shell -SHELL=/bin/sh - # Compiler flags CFLAGS=-Wall -O2 -static LDFLAGS=-static diff --git a/config/image-readme.txt b/config/image-readme.txt index 08cc0d6..c602943 100644 --- a/config/image-readme.txt +++ b/config/image-readme.txt @@ -5,8 +5,8 @@ This is a UEFI-bootable disk image with: - EFI System Partition (ESP) with FAT32 filesystem - GRUB UEFI bootloader - Linux kernel -- SparkOS init system -- Busybox utilities +- SparkOS init system (self-contained, no external dependencies) +- Qt6 GUI application The image can be written to a USB drive and booted on UEFI systems: sudo dd if=sparkos.img of=/dev/sdX bs=4M status=progress @@ -15,6 +15,9 @@ The image can be written to a USB drive and booted on UEFI systems: Boot options: - UEFI boot support (tested on x86_64 systems) - Automatic boot after 3 seconds -- Console on tty1 +- Direct boot to Qt6 GUI (no CLI) +- Console on tty1 (for debugging only) + +Philosophy: GUI-only, no CLI tools, network-first For more information, see: https://github.com/johndoe6345789/SparkOS diff --git a/config/image-release-readme.txt b/config/image-release-readme.txt index a8d0a38..67fc3b7 100644 --- a/config/image-release-readme.txt +++ b/config/image-release-readme.txt @@ -12,15 +12,16 @@ What's Included: ✓ EFI System Partition (ESP) with FAT32 filesystem ✓ GRUB UEFI bootloader ✓ Linux kernel -✓ SparkOS init system -✓ Busybox utilities -✓ Basic FHS-compliant filesystem structure +✓ SparkOS init system (self-contained, no dependencies) +✓ Qt6 GUI application +✓ Minimal filesystem structure Boot Support: ------------ ✓ UEFI boot (x86_64 systems) ✓ Automatic boot after 3 seconds -✓ Console on tty1 +✓ Direct boot to Qt6 GUI (no CLI) +✓ Console on tty1 (for debugging only) Quick Start: ----------- diff --git a/scripts/build.sh b/scripts/build.sh index 392921f..8833dd8 100755 --- a/scripts/build.sh +++ b/scripts/build.sh @@ -1,7 +1,6 @@ #!/bin/bash # Quick build script for SparkOS development # Note: This script runs on the host system and uses bash for ${BASH_SOURCE} -# The target system uses busybox sh instead. set -e @@ -30,10 +29,9 @@ echo "" echo "Build complete!" echo "" echo "Next steps to create a full bootable system:" -echo " 1. Copy busybox to rootfs/bin/" -echo " (cp /bin/busybox rootfs/bin/)" -echo " 2. Create symlinks in rootfs/bin for common utilities" -echo " (cd rootfs/bin && for cmd in sh ls cat mkdir rm cp mount; do ln -sf busybox \$cmd; done)" -echo " 3. Add a Linux kernel to rootfs/boot/vmlinuz" -echo " 4. Run: sudo make image" +echo " 1. Build Qt6 GUI: make gui" +echo " 2. Add a Linux kernel to rootfs/boot/vmlinuz" +echo " 3. Run: sudo make image" +echo "" +echo "Philosophy: No CLI tools, GUI-only experience" echo "" diff --git a/scripts/create_image.sh b/scripts/create_image.sh index 8693fde..c4f744d 100755 --- a/scripts/create_image.sh +++ b/scripts/create_image.sh @@ -1,8 +1,6 @@ #!/bin/bash # SparkOS Image Creation Script # Creates a bootable dd-able disk image -# Note: This script runs on the host system and uses bash for ${BASH_SOURCE} -# The target system uses busybox sh instead. set -e diff --git a/scripts/docker-image-create-uefi-old.sh b/scripts/docker-image-create-uefi-old.sh index 87497f9..31bb90e 100755 --- a/scripts/docker-image-create-uefi-old.sh +++ b/scripts/docker-image-create-uefi-old.sh @@ -86,23 +86,10 @@ mkdir -p /staging/root/{bin,sbin,etc,proc,sys,dev,tmp,usr/{bin,sbin,lib,lib64},v cp /build/init /staging/root/sbin/init chmod 755 /staging/root/sbin/init -# Install busybox -echo "Installing busybox..." -cp /bin/busybox /staging/root/bin/busybox -chmod 755 /staging/root/bin/busybox - -# Create busybox symlinks for essential commands -for cmd in sh ls cat echo mount umount mkdir rm cp mv chmod chown ln ps kill; do - ln -sf busybox /staging/root/bin/$cmd -done - # Create system configuration files echo "sparkos" > /staging/root/etc/hostname echo "127.0.0.1 localhost" > /staging/root/etc/hosts echo "127.0.1.1 sparkos" >> /staging/root/etc/hosts -echo "root:x:0:0:root:/root:/bin/sh" > /staging/root/etc/passwd -echo "spark:x:1000:1000:SparkOS User:/home/spark:/bin/sh" >> /staging/root/etc/passwd -echo "root:x:0:" > /staging/root/etc/group echo "spark:x:1000:" >> /staging/root/etc/group # Copy README to root partition diff --git a/scripts/docker-image-create-uefi.sh b/scripts/docker-image-create-uefi.sh index a61dd5b..a2afd64 100755 --- a/scripts/docker-image-create-uefi.sh +++ b/scripts/docker-image-create-uefi.sh @@ -61,23 +61,10 @@ mkdir -p /staging/root/{bin,sbin,etc,proc,sys,dev,tmp,usr/{bin,sbin,lib,lib64},v cp /build/init /staging/root/sbin/init chmod 755 /staging/root/sbin/init -# Install busybox -echo "Installing busybox..." -cp /bin/busybox /staging/root/bin/busybox -chmod 755 /staging/root/bin/busybox - -# Create busybox symlinks for essential commands -for cmd in sh ls cat echo mount umount mkdir rm cp mv chmod chown ln ps kill; do - ln -sf busybox /staging/root/bin/$cmd -done - # Create system configuration files echo "sparkos" > /staging/root/etc/hostname echo "127.0.0.1 localhost" > /staging/root/etc/hosts echo "127.0.1.1 sparkos" >> /staging/root/etc/hosts -echo "root:x:0:0:root:/root:/bin/sh" > /staging/root/etc/passwd -echo "spark:x:1000:1000:SparkOS User:/home/spark:/bin/sh" >> /staging/root/etc/passwd -echo "root:x:0:" > /staging/root/etc/group echo "spark:x:1000:" >> /staging/root/etc/group # Copy README to root partition diff --git a/scripts/docker-image-install-tools.sh b/scripts/docker-image-install-tools.sh index c9303f3..7ad9fd8 100755 --- a/scripts/docker-image-install-tools.sh +++ b/scripts/docker-image-install-tools.sh @@ -22,7 +22,6 @@ apt-get install -y \ grub-efi-amd64-bin \ grub-common \ wget \ - busybox-static \ kmod \ udev rm -rf /var/lib/apt/lists/* diff --git a/scripts/docker-release.sh b/scripts/docker-release.sh index 60359db..cd33d28 100755 --- a/scripts/docker-release.sh +++ b/scripts/docker-release.sh @@ -143,8 +143,8 @@ Build release artifacts without needing root or special tools: ## System Requirements -- Linux system with kernel 3.x or later -- Busybox for shell and utilities +- Linux system with kernel 3.x or later with framebuffer support +- Qt6 runtime libraries for GUI - For building: Docker or GCC compiler and Make ## Documentation