Add mode READMEs and move Bigscreen app

Add comprehensive READMEs for Bigscreen and Desktop modes, and relocate the Tauri frontend prototype into a new Bigscreen/ subdirectory. This moves package.json/package-lock, src, src-tauri, assets, views, styles and related files into Bigscreen/ to separate the controller-first shell from top-level docs. Update the root README.md to reframe the project as "NebulaOS", describe Bigscreen/Desktop modes, the vision, tech stack and development notes. This reorganizes the repo layout for clearer mode separation and documentation.

Bigscreen/README-Bigscreen.md

@@ -0,0 +1,305 @@
+# NebulaOS Bigscreen Mode
+
+Bigscreen Mode is the controller-first console interface for NebulaOS.
+
+It is designed for gaming PCs, handhelds, TVs, and couch-based setups where the primary input is a controller rather than a mouse and keyboard.
+
+Bigscreen Mode should feel like the main dashboard of a console, but with the freedom of a Linux PC underneath.
+
+---
+
+## Purpose
+
+Bigscreen Mode exists to make NebulaOS feel native on gaming hardware.
+
+It provides:
+
+* A controller-first home screen
+* A game and app library
+* System settings
+* Power controls
+* Profile and lock screen flows
+* Store and launcher integrations
+* A fullscreen interface for TV and handheld use
+
+The goal is not to copy Steam Big Picture or Xbox exactly.
+
+The goal is to create an open, polished, flexible OS shell that feels good to use with a controller.
+
+---
+
+## Current Features
+
+The current v0 prototype includes:
+
+* Lock screen with PIN keypad
+* Controller and keyboard input support
+* Home dashboard
+* Library stub
+* Settings stub
+* Power overlay
+* Controller focus management
+* Keyboard mirror controls for development
+* Xbox-inspired horizontal tile layout
+* Dynamic nebula background stack
+* Smooth focus transitions
+* Shared top bar with profile and time display
+
+---
+
+## Input Model
+
+Bigscreen Mode uses unified input actions instead of raw button handling.
+
+Core actions:
+
+```text
+up
+down
+left
+right
+accept
+back
+menu
+```
+
+These actions can come from:
+
+* Controller D-pad
+* Controller left stick
+* Controller face buttons
+* Keyboard arrow keys
+* Enter
+* Escape
+* Backspace
+
+This keeps the UI consistent across controllers, keyboards, and future input devices.
+
+---
+
+## Controller Mapping
+
+```text
+D-pad / left stick: Navigate
+A: Accept
+B: Back
+Start: Menu
+```
+
+Future mappings may include:
+
+```text
+LB / RB: Switch tabs or rails
+LT / RT: Page navigation
+Guide button: Nebula overlay
+Y: Search
+X: Context action
+```
+
+---
+
+## Design Goals
+
+Bigscreen Mode should be:
+
+* Fast
+* Clear
+* Controller-first
+* Readable from a distance
+* Comfortable on TVs
+* Comfortable on handheld screens
+* Smooth and polished
+* Visually distinct from desktop Linux
+* Easy to navigate without a mouse
+
+---
+
+## UI Structure
+
+Bigscreen Mode is planned around the following major areas:
+
+```text
+Bigscreen Mode
+├── Lock Screen
+├── Home
+├── Library
+├── Store
+├── Apps
+├── Settings
+├── Downloads
+├── Notifications
+├── Power Menu
+└── Profile Menu
+```
+
+---
+
+## Home
+
+The Home screen is the main landing area.
+
+It should include:
+
+* Recent games
+* Installed games
+* Featured apps
+* Continue playing section
+* Quick settings
+* Profile status
+* Time and network status
+* Download status
+* Power menu access
+
+The current prototype uses a horizontal app tile rail with Library, Settings, and Power tiles.
+
+---
+
+## Library
+
+The Library is the game and app management area.
+
+Initial v0 scope:
+
+* Display mock entries
+* Display locally added games
+* Launch local executables
+* Store metadata locally
+* Support controller navigation
+* Separate games from apps
+
+Future scope:
+
+* Steam integration
+* GOG integration
+* Epic Games integration
+* Proton and Wine configuration
+* Per-game settings
+* Save sync support
+* Mod manager integration
+* Metadata and artwork scraping
+
+---
+
+## Settings
+
+Settings should expose system controls in a controller-friendly way.
+
+Planned categories:
+
+* Network
+* Bluetooth
+* Audio
+* Display
+* Controller
+* Storage
+* Accounts
+* Appearance
+* Updates
+* System
+* Desktop Mode
+
+The settings UI should avoid feeling like a desktop control panel.
+It should feel like a native console settings app.
+
+---
+
+## Lock Screen
+
+The lock screen currently supports a v0 PIN keypad.
+
+Current v0 PIN:
+
+```text
+1234
+```
+
+Future improvements:
+
+* User profiles
+* Custom PINs
+* Avatar selection
+* Local account linking
+* Parental controls
+* Optional password fallback
+* Automatic login into Bigscreen profile
+
+---
+
+## Power Menu
+
+The power overlay should support:
+
+* Sleep
+* Restart
+* Shut down
+* Log out
+* Switch to Desktop Mode
+* Return to login
+* Restart Bigscreen shell
+
+Current v0 scope includes a power overlay that traps focus and closes with Back.
+
+---
+
+## Technology
+
+Bigscreen Mode is built with:
+
+* Tauri
+* HTML
+* CSS
+* JavaScript
+* Rust backend through Tauri
+* Web Gamepad API
+* Nebula Core adapters
+
+---
+
+## Run
+
+From the root of the repository:
+
+```bash
+npm install
+npm run dev
+```
+
+---
+
+## Build
+
+```bash
+npm run build
+```
+
+---
+
+## Development Notes
+
+Bigscreen Mode is currently developed primarily on Windows for faster UI iteration.
+
+Linux testing is still required for:
+
+* Fullscreen behavior
+* Session integration
+* Controller detection
+* System commands
+* App launching
+* Proton and Wine workflows
+* Power controls
+
+---
+
+## Success Criteria
+
+Bigscreen Mode is successful when:
+
+* The entire interface works with a controller
+* Users can unlock the system
+* Users can navigate Home
+* Users can open Library
+* Users can open Settings
+* Users can launch games or apps
+* Users can access power controls
+* Users can switch to Desktop Mode
+* The UI feels like a native OS shell, not a web app

Desktop/README-Desktop.md

@@ -0,0 +1,271 @@
+# NebulaOS Desktop Mode
+
+Desktop Mode is the full Linux desktop experience for NebulaOS.
+
+It exists because NebulaOS should not only be a console-style interface.
+It should also be a capable desktop operating system when the user needs one.
+
+Bigscreen Mode is for controller-first gaming and media.
+Desktop Mode is for everything else.
+
+---
+
+## Purpose
+
+Desktop Mode gives users access to a normal computer environment.
+
+It is designed for:
+
+* File management
+* Web browsing
+* Productivity
+* Development
+* Modding
+* Troubleshooting
+* Advanced settings
+* Desktop gaming
+* App management
+* System maintenance
+
+NebulaOS should feel simple in Bigscreen Mode, but never locked down.
+
+Desktop Mode is what keeps NebulaOS flexible.
+
+---
+
+## Recommended Foundation
+
+The recommended Desktop Mode foundation is:
+
+* Linux
+* KDE Plasma
+* SDDM
+* Wayland where possible
+* X11 fallback where needed
+* Custom Nebula theme
+* Custom Nebula session entries
+
+KDE Plasma is recommended because it is:
+
+* Highly customizable
+* Friendly to Linux gaming workflows
+* Themeable
+* Mature
+* Flexible
+* Suitable for both desktop and handheld layouts
+
+---
+
+## Design Direction
+
+Desktop Mode should feel:
+
+* Clean
+* Smooth
+* Modern
+* Minimal
+* Polished
+* Fast
+* Familiar
+* Slightly futuristic
+
+The design should take inspiration from the clarity and polish of macOS while keeping the flexibility and openness of Linux.
+
+NebulaOS Desktop Mode should not look like a generic KDE install forever.
+The long-term goal is to make it feel like a distinct Nebula desktop experience.
+
+---
+
+## Desktop Mode Responsibilities
+
+Desktop Mode should provide:
+
+* File manager access
+* Browser access
+* Terminal access
+* App launcher
+* System settings
+* Development tools
+* Game modding tools
+* Desktop game launching
+* Access to Bigscreen Mode
+* Advanced troubleshooting tools
+
+---
+
+## Relationship to Bigscreen Mode
+
+NebulaOS has two main sessions:
+
+```text
+Nebula Bigscreen
+Nebula Desktop
+```
+
+### Bigscreen Mode
+
+Used for:
+
+* Controller navigation
+* Game launching
+* TV use
+* Handheld use
+* Couch workflows
+* Simple settings
+* Console-like experience
+
+### Desktop Mode
+
+Used for:
+
+* Mouse and keyboard use
+* Advanced configuration
+* Development
+* File browsing
+* Modding
+* Productivity
+* Troubleshooting
+
+Both modes should feel connected, but they should not try to do the same job.
+
+---
+
+## Session Switching
+
+Long-term, NebulaOS should allow users to switch between modes easily.
+
+Possible flows:
+
+```text
+Bigscreen Mode → Power Menu → Switch to Desktop Mode
+Desktop Mode → App Launcher → Return to Bigscreen Mode
+Login Screen → Choose Nebula Bigscreen or Nebula Desktop
+```
+
+The user should never feel trapped in either mode.
+
+---
+
+## KDE Customization Goals
+
+Desktop Mode customization may include:
+
+* Nebula global theme
+* Nebula icon theme
+* Nebula cursor theme
+* Nebula wallpaper set
+* Custom SDDM theme
+* Custom splash screen
+* Custom panel layout
+* Custom application launcher
+* Custom desktop widgets
+* Preinstalled Nebula apps
+* Desktop shortcut for Bigscreen Mode
+
+---
+
+## Suggested Desktop Layout
+
+A possible default layout:
+
+```text
+Top panel
+├── App launcher
+├── Active window title
+├── System tray
+├── Network
+├── Audio
+├── Battery
+└── Clock
+
+Desktop
+├── Nebula wallpaper
+├── Minimal icons
+└── Optional widgets
+
+Dock or bottom panel
+├── Browser
+├── Files
+├── Terminal
+├── Settings
+├── Nebula Bigscreen
+└── Nebula Library
+```
+
+---
+
+## Visual Identity
+
+Desktop Mode should share visual DNA with Bigscreen Mode.
+
+Shared elements may include:
+
+* Nebula gradients
+* Deep blue and purple tones
+* Soft glass panels
+* Rounded corners
+* Subtle glow
+* Clean typography
+* Space-inspired wallpapers
+* Calm animation
+* Consistent icon language
+
+Desktop Mode should be calmer and more practical than Bigscreen Mode, but still recognizably Nebula.
+
+---
+
+## System Tools
+
+Desktop Mode may eventually include Nebula-specific tools such as:
+
+* Nebula Control Center
+* Nebula Update Manager
+* Nebula Library desktop app
+* Nebula Browser
+* Nebula Store
+* Nebula Settings bridge
+* Nebula account/profile manager
+* Nebula system diagnostics
+
+---
+
+## Development Goals
+
+Initial Desktop Mode goals:
+
+* Pick KDE Plasma as the base
+* Create a Nebula desktop theme
+* Create a Nebula SDDM login theme
+* Add Bigscreen and Desktop sessions
+* Add a launcher shortcut back into Bigscreen Mode
+* Keep normal Linux tools available
+* Avoid breaking standard KDE functionality
+
+---
+
+## What Desktop Mode Should Avoid
+
+Desktop Mode should avoid:
+
+* Removing normal Linux functionality
+* Hiding important system tools
+* Making KDE harder to use
+* Becoming too console-like
+* Depending on Bigscreen Mode to function
+* Locking users into one workflow
+
+Desktop Mode should be powerful, normal, and clean.
+
+---
+
+## Success Criteria
+
+Desktop Mode is successful when:
+
+* Users can use NebulaOS like a normal Linux desktop
+* KDE feels visually integrated with NebulaOS
+* Bigscreen Mode can be launched easily
+* Advanced settings are accessible
+* Development and troubleshooting are possible
+* The desktop feels polished instead of temporary
+* The system still feels like one unified OS

README.md

@@ -1,51 +1,290 @@
-# Nebula OS v0 – Windows-first Development Plan
+# NebulaOS
 
-## Nebula OS Prototype (Current)
+NebulaOS is an open source Linux-based operating system experience built around two modes:
 
-This repository now includes a working v0 Nebula OS prototype in the Tauri frontend (`src/`) with:
+1. **Bigscreen Mode**: a controller-first console-style interface for games, apps, media, settings, and system navigation.
+2. **Desktop Mode**: a clean KDE-based desktop experience for productivity, development, file management, and advanced system control.
 
-- Lock Screen with controller/keyboard PIN keypad (`1234` for v0)
+NebulaOS is not just a launcher, Steam skin, or Big Picture replacement.
-- Home dashboard tile grid (Library, Settings, Power)
+It is a full OS experience designed to make Linux feel native on gaming PCs, handhelds, TV setups, and eventually dedicated console-like hardware.
-- Settings split-pane stub (category list + content panel)
-- Library stub view with controller back behavior
-- Start/Menu power overlay that traps focus and closes with Back
-- Unified input actions (`up/down/left/right/accept/back/menu`) from keyboard + gamepad
 
-### Dashboard refresh (Xbox-inspired Nebula)
+The goal is to combine the best parts of console UX, desktop Linux, and modern operating system design into one flexible system.
 
-The shell now uses a premium horizontal dashboard language inspired by console UI patterns:
+---
 
-- Left-aligned horizontal app tile rail (Library, Settings, Power)
+## Vision
-- Dynamic nebula background stack (gradient, starfield, fog, vignette)
-- Shared top bar with reactive accent line and profile/time status
-- Layered tile focus states (scale, cyan glow, ripple, elevation)
-- Smooth page/focus transitions with cubic-bezier motion curves
-- Immersive lock screen with large clock/date and input-revealed PIN panel
-- Settings redesign with top category rail + card-based content panel
 
-Animation and component architecture notes are in [src/styles/shell-guidelines.md](src/styles/shell-guidelines.md).
+NebulaOS is designed around a simple idea:
 
-### Install
+> A gaming OS should feel like a console when you are gaming, and like a real desktop when you need one.
+
+Most gaming-focused Linux setups are either:
+
+* Too desktop-oriented for controller use
+* Too launcher-dependent
+* Too tied to Steam
+* Too limited when the user needs full desktop control
+
+NebulaOS aims to solve that by providing both:
+
+* A polished controller-first Bigscreen interface
+* A proper Linux desktop mode
+
+The long-term goal is to create an OS that can work as:
+
+* A Steam Deck-style handheld interface
+* A living room gaming console UI
+* A gaming PC frontend
+* A full Linux desktop
+* A foundation for future Nebula hardware
+
+---
+
+## Modes
+
+### Bigscreen Mode
+
+Bigscreen Mode is the main console-style experience.
+
+It is designed for:
+
+* Controllers
+* TVs
+* Handhelds
+* Game launching
+* App launching
+* System settings
+* Power controls
+* Profiles
+* Media-focused workflows
+
+Bigscreen Mode is built as a fullscreen Nebula shell using Tauri, HTML, CSS, JavaScript, and a controller-first navigation system.
+
+Current v0 features include:
+
+* Lock screen with controller and keyboard PIN keypad
+* Home dashboard tile grid
+* Library screen
+* Settings screen
+* Power overlay
+* Unified input actions from keyboard and gamepad
+* Xbox-inspired horizontal dashboard layout
+* Dynamic nebula background visuals
+* Controller focus states and smooth transitions
+
+Read more in:
+
+```text
+bigscreen/README.md
+```
+
+---
+
+### Desktop Mode
+
+Desktop Mode is the full Linux desktop experience.
+
+It is intended for:
+
+* File browsing
+* Productivity
+* Web browsing
+* Development
+* System configuration
+* Troubleshooting
+* Advanced settings
+* Desktop gaming workflows
+
+The recommended Desktop Mode foundation is KDE Plasma because it is flexible, themeable, controller-adaptable, and already well-suited to Linux gaming environments.
+
+Desktop Mode should feel clean, modern, and polished, with a design direction inspired by the clarity and smoothness of macOS while keeping the flexibility of Linux.
+
+Read more in:
+
+```text
+Desktop/README.md
+```
+
+---
+
+## What NebulaOS Is
+
+NebulaOS is:
+
+* A Linux-based gaming operating system experience
+* A controller-first shell for Bigscreen use
+* A KDE-based desktop experience for normal computer use
+* A unified game and app launcher
+* A modular platform for Nebula apps
+* An open alternative to proprietary gaming frontends
+* A foundation for future console-like hardware
+
+---
+
+## What NebulaOS Is Not
+
+NebulaOS is not:
+
+* A Steam skin
+* A Steam Big Picture clone
+* A launcher-only project
+* A proprietary console OS
+* A replacement for Linux itself
+* A locked-down gaming environment
+
+NebulaOS should work with Steam, GOG, Epic Games, local apps, native Linux games, Proton, Wine, and other tools without depending on one company’s frontend.
+
+---
+
+## Core Principles
+
+1. **Controller-first, not controller-compatible**
+   Bigscreen Mode should be designed from the ground up for controller navigation.
+
+2. **Desktop when needed**
+   Users should always be able to access a proper desktop environment.
+
+3. **Open and modular**
+   NebulaOS should be built from replaceable, understandable components.
+
+4. **Independent from proprietary launchers**
+   Store integrations should exist, but NebulaOS should have its own interface.
+
+5. **Console feel, PC freedom**
+   NebulaOS should feel simple and polished without removing user control.
+
+6. **Built for iteration**
+   v0 should be simple, but the architecture should leave room for long-term growth.
+
+---
+
+## High-Level Architecture
+
+NebulaOS is split into several layers:
+
+```text
+NebulaOS
+├── Bigscreen Mode
+│   ├── Nebula Home
+│   ├── Nebula Library
+│   ├── Controller Settings
+│   ├── Power Menu
+│   └── Profile / Lock Screen
+│
+├── Desktop Mode
+│   ├── KDE Plasma
+│   ├── Nebula desktop theme
+│   ├── Desktop apps
+│   └── Advanced system tools
+│
+├── Nebula Core
+│   ├── Input
+│   ├── Navigation
+│   ├── Theme
+│   ├── Glyphs
+│   └── Shared UI logic
+│
+└── System Integration Layer
+    ├── Game discovery
+    ├── App launching
+    ├── Store integrations
+    ├── Proton / Wine handling
+    ├── Network settings
+    ├── Audio settings
+    ├── Display settings
+    └── Power controls
+```
+
+---
+
+## Technology Stack
+
+### Bigscreen Mode
+
+* Tauri
+* HTML
+* CSS
+* JavaScript
+* Rust backend through Tauri
+* Web Gamepad API
+* Nebula Core
+
+### Desktop Mode
+
+* Linux
+* KDE Plasma
+* SDDM
+* Custom Nebula theme
+* Custom session configuration
+* Optional Nebula desktop tools
+
+### Game and App Layer
+
+Planned integrations include:
+
+* Native Linux apps
+* Local executables
+* Steam
+* SteamCMD
+* Proton
+* Wine
+* GOG
+* Epic Games
+* Legendary
+* Heroic backend concepts
+* Local metadata databases
+
+---
+
+## Current Repository Status
+
+This repository currently contains the early NebulaOS v0 prototype.
+
+Current features include:
+
+* Tauri frontend shell
+* Controller and keyboard input mapping
+* Lock screen
+* Home dashboard
+* Library stub
+* Settings stub
+* Power overlay
+* Nebula Core adapter structure
+* Xbox-inspired dashboard refresh
+* Windows-first development setup
+* Linux build pathway
+
+The project is currently focused on building the Bigscreen shell first, while planning Desktop Mode as the second major pillar of the OS.
+
+---
+
+## Install
 
 ```bash
 npm install
 ```
 
-### Run (dev)
+---
+
+## Run in Development
 
 ```bash
 npm run dev
 ```
 
-### Build
+---
+
+## Build
 
 ```bash
 npm run build
 ```
 
-### Linux prerequisites (Ubuntu/Debian)
+---
 
-Install system dependencies required by Tauri/WebKit:
+## Linux Prerequisites
+
+For Ubuntu, Debian, and related distributions, install the system dependencies required by Tauri and WebKit:
 
 ```bash
 sudo apt update
@@ -62,48 +301,75 @@ sudo apt install -y \
   libgtk-3-dev
 ```
 
-Install Node.js LTS and Rust (if not already installed), then run:
+You will also need:
+
+* Node.js LTS
+* Rust
+* npm
+
+Then run:
 
 ```bash
 npm install
 npm run dev
 ```
 
-### Controller testing notes (Windows)
+---
 
-- Connect an Xbox-compatible controller before launching dev mode.
+## Controller Testing
-- Navigation: D-pad or left stick.
-- Actions: `A` = Accept, `B` = Back, `Start` = Menu.
-- Keyboard mirror for development: arrow keys, Enter, Escape/Backspace.
 
-### Nebula Core integration status
+For development, connect an Xbox-compatible controller before launching the app.
 
-`@nebulaproject/core` is installed and used through runtime adapters in:
+### Controller Mapping
 
-- `src/core/input.js`
+```text
-- `src/core/nav.js`
+D-pad / left stick: Navigate
-- `src/core/state.js`
+A: Accept
+B: Back
+Start: Menu
+```
 
-If Nebula Core exports are available, the shell uses them for input/navigation/glyphs/theme.
+### Keyboard Mirror
-If not, local fallback adapters keep the shell fully functional.
 
-### Local Nebula Core development (Windows-safe)
+```text
+Arrow keys: Navigate
+Enter: Accept
+Escape / Backspace: Back
+```
 
-Current npm package `@nebulaproject/core@0.1.3` re-exports internal `@nebula/*` packages that are not published, so local linking is recommended for active core development.
+---
 
-1. Clone Nebula Core monorepo next to this repo.
+## Nebula Core Integration
-2. Build Nebula Core packages.
+
-3. Link from the core repo and consume in this repo:
+NebulaOS uses `@nebulaproject/core` through runtime adapters.
+
+Current adapter files:
+
+```text
+src/core/input.js
+src/core/nav.js
+src/core/state.js
+```
+
+If Nebula Core exports are available, NebulaOS uses them for input, navigation, glyphs, and theme handling.
+
+If they are unavailable, local fallback adapters keep the shell functional during development.
+
+---
+
+## Local Nebula Core Development
+
+For active local development, clone Nebula Core next to this repository.
 
 ```bash
 # In Nebula-Core repo
 npm link
 
-# In Nebula-OS repo
+# In NebulaOS repo
 npm link @nebulaproject/core
 ```
 
-Alternative (more deterministic): use `file:` dependency in `package.json`:
+Alternative deterministic setup using `file:` dependency:
 
 ```json
 {
@@ -119,341 +385,151 @@ Then run:
 npm install
 ```
 
-### Linux VM build (high-level)
-
-- Install Rust, Node.js, and the Linux prerequisites above.
-- Clone this repo in the Linux VM.
-- Run `npm install`.
-- Run `npm run dev` for integration checks in Linux session.
-- Run `npm run build` to produce Linux artifacts.
-
-## Vision
-
-Nebula OS is a **controller-first, open source operating system experience** built on Linux.
-
-It has two equally important jobs:
-
-1. **A custom controller-first way to navigate the OS** (like a console shell)
-2. **An open source library and launcher layer** for games and apps
-
-Nebula OS is not a skin that launches Steam.
-It is an independent UI layer that:
-
-* Acts as the primary **controller-first shell** for the OS
-* Provides a unified Home experience for **games, apps, and media**
-* Integrates first-install Nebula apps such as **Nebula Browser** and **Nebula Launcher**
-* Exposes **system settings** through controller-friendly panels
-* Manages game libraries directly (Steam, GOG, Epic, and others)
-
-Nebula OS v0 focuses on building the foundation for this console-grade OS shell.
-
 ---
 
-# Core Principles
+## Development Strategy
 
-1. Controller-first, not controller-compatible
+NebulaOS is currently developed across two environments.
-2. Replace proprietary frontends with an open interface
-3. Separate system layer from UI layer
-4. Build modular infrastructure for long-term independence
-5. Develop iteratively, but architect for autonomy
 
----
+### Windows
-
-# What Nebula OS v0 Actually Is
-
-Nebula OS v0 consists of:
-
-* Base OS: Ubuntu LTS (or Ubuntu-based)
-* Desktop Environment: KDE Plasma (recommended)
-* Display Manager: SDDM
-* Two login sessions:
-
-  * Nebula Desktop
-  * Nebula Game UI
-* Nebula OS (Tauri + HTML/CSS/JS)
-* Nebula Library (core application responsible for:
-
-  * Game discovery
-  * Installation
-  * Updates
-  * Launching
-  * Compatibility management)
-
-Unlike SteamOS, Nebula OS does not rely on launching Steam Big Picture.
-Nebula Library is the primary game management layer.
-
----
-
-# High-Level Architecture
-
-## Desktop Mode
-
-A standard KDE session for:
-
-* Productivity workflows
-* File browsing and system tools
-* Development and troubleshooting
-* Advanced configuration
-
-Desktop Mode remains a normal Linux desktop.
-
-## Game UI Mode
-
-A dedicated login session that launches **Nebula OS** fullscreen.
-
-Game UI Mode contains:
-
-* Lock screen with controller PIN entry
-* Nebula Home dashboard
-* Nebula Library
-* Controller-friendly Settings
-* Power and session controls
-
-Game UI Mode is the **console experience** for the entire OS.
-
-## System Integration Layer (behind the UI)
-
-Nebula OS needs a clean boundary between UI and system operations.
-
-Recommended approach:
-
-* A small privileged backend service (later) that exposes safe operations:
-
-  * Wi-Fi and networking
-  * Audio and output device selection
-  * Display resolution and scaling
-  * Bluetooth pairing
-  * Storage overview
-  * Power controls
-* The UI talks to that layer through a stable API
-
-v0 scope can start with non-privileged read-only data and a few safe commands.
-
----
-
-# Technology Stack
-
-## UI Layer
-
-* Tauri
-* HTML
-* CSS
-* JavaScript
-
-Why Tauri:
-
-* Lightweight
-* Native system integration via Rust backend
-* Cross-platform development
-* Efficient resource usage
-
-## Controller Input
-
-* Web Gamepad API
-* Custom focus/navigation system
-
-Controller mappings:
-
-* D-pad / left stick: navigation
-* A: activate
-* B: back
-* Start: menu
-* Shoulder buttons: future navigation layers
-
-Keyboard mirrors controller during development.
-
----
-
-# Nebula OS – The OS UI Layer
-
-Nebula OS is the **controller-first OS shell**.
-
-It is the primary interface in Game UI Mode and should feel like a console dashboard, not a desktop.
-
-Nebula OS responsibilities:
-
-* Home dashboard (games, apps, recent activity)
-* App launcher for integrated Nebula apps (Nebula Browser, Nebula Launcher, Nebula Library, Settings)
-* System navigation (network, audio, display, storage, accounts)
-* Power menu and session switching (Game UI ↔ Desktop)
-* Notifications and downloads (later)
-* Controller-first focus navigation everywhere
-
-Nebula OS is built with Tauri + HTML/CSS/JS.
-
----
-
-# Nebula Library – The Game and App Management Layer
-
-Nebula Library is the **content manager** inside Nebula OS.
-
-It is not a bridge to proprietary UIs.
-It should eventually handle:
-
-* Steam installs via SteamCMD and/or open APIs
-* GOG installs via open or community tooling
-* Epic installs via open tooling (for example Legendary)
-* Proton/Wine configuration and per-title settings
-* Game launch parameters and runtime selection
-* Updates, integrity checks, and metadata
-
-Initial v0 scope:
-
-* Library UI skeleton and data model
-* Local entries (manual add)
-* Launch local executables
-* Foundation for compatibility and store backends
-
-Long-term direction:
-
-Nebula Library becomes a unified open source platform for managing games and apps.
-
----
-
-# Development Strategy
-
-Nebula OS is developed in two environments:
-
-## Windows (Primary UI Development)
 
 Used for:
 
-* Building Nebula OS UI
+* UI development
-* Implementing controller navigation
+* Controller navigation
-* Designing lock screen
+* Lock screen work
-* Designing Library UI
+* Library UI
-* Building system state architecture
+* Settings UI
+* Frontend architecture
 
-UI and logic are platform-agnostic.
+### Linux VM
-
-## Linux VM (Integration & Replacement Layer)
 
 Used for:
 
-* Building Linux binaries
+* Linux builds
-* Session integration
+* Session testing
-* SteamCMD integration testing
+* KDE integration
-* Proton/Wine configuration
+* Fullscreen shell testing
-* System-level testing
+* Proton and Wine experiments
+* System service experiments
 
-Rule:
+The current workflow is:
 
-Develop UI on Windows.
+```text
-Build and test Linux features inside the VM.
+Design and build the UI on Windows.
+Test OS-level behavior in Linux.
+```
 
 ---
 
-# Phase Roadmap
+## Roadmap
 
-## Phase 1 – Nebula OS (Controller Console Layer)
+### Phase 1: Bigscreen Shell
 
-Objective:
+Goal: Build a polished controller-first shell.
-Build a polished, console-grade Game UI independent of store integration.
 
 Deliverables:
 
-* Lock screen with PIN keypad
+* Lock screen
 * Home dashboard
-* Library screen (mock data)
+* Library screen
 * Settings screen
 * Power menu
-* Controller navigation grid system
+* Controller navigation
-* Fullscreen window behavior
+* Fullscreen mode
-
+* Basic app launching
-No external integrations yet.
 
 ---
 
-## Phase 2 – Session Integration
+### Phase 2: Desktop Mode Foundation
 
-Objective:
+Goal: Create the NebulaOS desktop environment experience.
-Make Nebula OS a selectable login session.
 
-Milestones:
+Deliverables:
 
-* Nebula Game UI appears at login
+* KDE Plasma setup
-* Launches fullscreen
+* Nebula theme
-* Exiting returns to login
+* SDDM login configuration
-* Controller works reliably
+* Bigscreen and Desktop session entries
+* Desktop-to-Bigscreen switching
+* Basic Nebula desktop tools
 
 ---
 
-## Phase 3 – Nebula Library Foundations
+### Phase 3: Session Integration
 
-Objective:
+Goal: Make NebulaOS feel like a real OS experience.
-Begin true replacement behavior.
 
-Milestones:
+Deliverables:
 
-* Launch local Linux games
+* Bigscreen session selectable from login
-* Integrate Proton/Wine execution layer
+* Desktop session selectable from login
-* Add SteamCMD support for installing Steam titles
+* Bigscreen launches fullscreen
-* Track installed game metadata
+* Exit to desktop or login
-* Unified library view
+* Controller works reliably in Bigscreen Mode
-
-This is where Nebula begins diverging from SteamOS.
 
 ---
 
-## Phase 4 – Store Integrations
+### Phase 4: Nebula Library Foundation
 
-Objective:
+Goal: Begin true game and app management.
-Add real backend integration without proprietary UI.
 
-Potential directions:
+Deliverables:
 
-* SteamCMD for Steam installs
+* Local app database
-* Legendary (Epic CLI) integration
+* Installed games database
-* Heroic backend reuse (without UI dependency)
+* Manual game adding
-* OpenGOG community tools
+* Local executable launching
-
+* Metadata structure
-Nebula Library becomes the single UI.
+* Cover art and banner support
+* Store backend abstraction
 
 ---
 
-# Security Strategy
+### Phase 5: Store and Compatibility Integrations
 
-Game UI lock screen:
+Goal: Turn Nebula Library into a real open game manager.
 
-* Local PIN authentication
+Potential integrations:
-* Optional profile system (future)
 
-Linux account authentication remains system-level.
+* SteamCMD
+* Proton
+* Wine
+* Legendary for Epic Games
+* GOG tooling
+* Heroic backend concepts
+* Per-game compatibility settings
 
 ---
 
-# What Nebula OS Is Not
+## Success Criteria for v0
 
-* Not a Steam skin
+NebulaOS v0 is successful when:
-* Not Big Picture mode
-* Not a launcher aggregator
-* Not dependent on proprietary UIs
 
-It is an open system layer that manages games directly.
+* Bigscreen Mode can be launched fullscreen
+* The entire shell is controller navigable
+* The lock screen works
+* The Home dashboard works
+* The Library can display and launch local entries
+* Settings has a usable controller-first structure
+* Power controls exist
+* Desktop Mode remains accessible
+* Bigscreen and Desktop feel like two parts of the same OS
 
 ---
 
-# Immediate Action Plan
+## Long-Term Goal
 
-1. Build Nebula OS UI on Windows
+NebulaOS should become a gaming OS that feels native, polished, and open.
-2. Implement controller navigation framework
-3. Build lock screen system
-4. Build Library UI skeleton
-5. Set up Linux VM
-6. Create Nebula Game UI login session
-7. Begin local executable launching support
-8. Research SteamCMD integration
 
----
+A user should be able to:
 
-# Success Criteria for v0
+* Turn on a machine
+* Pick up a controller
+* Navigate the whole system
+* Launch a game
+* Switch to Desktop Mode when needed
+* Manage apps, games, settings, and profiles
+* Use the system without needing Steam Big Picture or a traditional desktop launcher
 
-Nebula OS v0 is successful when:
+NebulaOS is the bridge between a console experience and a real computer.
-
-* You can log into Nebula Game UI
-* The entire UI is controller navigable
-* Lock screen works
-* You can launch locally managed games
-* You can return to Desktop Mode
-
-From there, Nebula Library evolves into a true open source game management platform.