From 627c52a5b7f279c594a27f901e58ae048d9718fe Mon Sep 17 00:00:00 2001 From: Andrew Zambazos Date: Sat, 23 May 2026 17:33:12 +1200 Subject: [PATCH] Make Bigscreen a Qt shell; move login to OS Update documentation to treat the Tauri/HTML prototype as legacy and define Bigscreen as a native Qt/QML/C++ shell. Remove in-shell PIN/login as a target feature and clarify that account selection, sign-in, and session choice are handled by a controller-friendly OS login (SDDM) implemented under Desktop Mode. Add phased plan, build/run notes for Qt vs legacy Tauri prototype, and clarify session/login workflow and responsibilities across Bigscreen/, Desktop/, and the top-level README. --- Bigscreen/README-Bigscreen.md | 132 ++++++++++++++++++++++++++-------- Desktop/README-Desktop.md | 36 +++++++--- README.md | 79 ++++++++++---------- 3 files changed, 167 insertions(+), 80 deletions(-) diff --git a/Bigscreen/README-Bigscreen.md b/Bigscreen/README-Bigscreen.md index 0f6c555..5d36377 100644 --- a/Bigscreen/README-Bigscreen.md +++ b/Bigscreen/README-Bigscreen.md @@ -18,10 +18,12 @@ It provides: * A game and app library * System settings * Power controls -* Profile and lock screen flows +* Profile status and quick user actions (not OS login) * Store and launcher integrations * A fullscreen interface for TV and handheld use +Account selection, sign-in, and first-time setup live on the **OS login screen** (see [Plan](#plan)), not inside Bigscreen. + 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. @@ -30,9 +32,9 @@ The goal is to create an open, polished, flexible OS shell that feels good to us ## Current Features -The current v0 prototype includes: +The current v0 **Tauri prototype** includes: -* Lock screen with PIN keypad +* Lock screen with PIN keypad (prototype only; not part of the target Qt shell) * Controller and keyboard input support * Home dashboard * Library stub @@ -119,8 +121,7 @@ Bigscreen Mode should be: Bigscreen Mode is planned around the following major areas: ```text -Bigscreen Mode -├── Lock Screen +Bigscreen Mode (after OS login) ├── Home ├── Library ├── Store @@ -132,6 +133,16 @@ Bigscreen Mode └── Profile Menu ``` +OS-level (Desktop Mode / KDE work, not inside Bigscreen): + +```text +NebulaOS login (SDDM) +├── Controller-friendly account picker +├── Sign in +├── Session choice (Bigscreen vs Desktop) +└── First-run / account setup when needed +``` + --- ## Home @@ -192,7 +203,7 @@ Planned categories: * Display * Controller * Storage -* Accounts +* Signed-in user (read-only; account changes via OS login / Desktop) * Appearance * Updates * System @@ -203,25 +214,59 @@ It should feel like a native console settings app. --- -## Lock Screen +## Login and sessions -The lock screen currently supports a v0 PIN keypad. +Bigscreen Mode does **not** own account creation, authentication, or session selection. -Current v0 PIN: +Those belong to a **controller-friendly NebulaOS login experience** built as part of [Desktop Mode](../Desktop/README-Desktop.md): KDE Plasma customization, SDDM theming, and session entries for Nebula Bigscreen and Nebula Desktop. Users pick an account and session at boot; Bigscreen starts already signed in. -```text -1234 -``` +The Tauri v0 **lock screen with PIN keypad** (`1234` in the prototype) was only for early UI testing. It will not ship in the Qt shell. If the OS needs a lock or suspend screen later, that should stay at the session/login layer or use the desktop stack—not a second login flow inside Bigscreen. -Future improvements: +Bigscreen may still show **who is signed in** (avatar, name) and offer **Log out** / **Switch user** via the power menu, which returns to the OS login screen. -* User profiles -* Custom PINs -* Avatar selection -* Local account linking -* Parental controls -* Optional password fallback -* Automatic login into Bigscreen profile +--- + +## Plan + +NebulaOS is no longer “Bigscreen first, desktop later.” **Desktop Mode is being built in parallel** on KDE Plasma, and that work unlocks a proper OS login so Bigscreen can stay a game shell. + +### Phase 1 — Desktop Mode foundation (in progress) + +Handled in `Desktop/`, not in Bigscreen: + +* KDE Plasma theme and look-and-feel +* Nebula visual identity on panels, widgets, and dialogs +* Repo-based apply/reload workflow for Plasma assets + +### Phase 2 — OS login and sessions + +Also primarily Desktop / system integration: + +* Controller-friendly **SDDM** login theme +* Account picker and sign-in usable with a gamepad +* Session entries: **Nebula Bigscreen** and **Nebula Desktop** +* First-run or account setup on the login/desktop side when needed +* Log out / switch user returns here + +Bigscreen does not implement PIN keypads, local account linking, or onboarding wizards for new users. + +### Phase 3 — Bigscreen Qt shell + +* Native Qt/QML shell (see [Technology](#technology)) +* Home, Library, Settings, Power menu +* Controller-first navigation and focus model +* Launch games and apps into the signed-in user session +* Switch to Desktop Mode; restart shell; no embedded login + +### Phase 4 — Library and integrations + +* Local library database and scanners +* Store and launcher integrations +* Proton/Wine and per-game settings (later) + +### Prototype note + +The Tauri/HTML v0 under `Bigscreen/` remains useful for layout and input experiments until the Qt shell replaces it. Treat its lock screen and onboarding flows as **throwaway**, not roadmap deliverables. --- @@ -243,21 +288,34 @@ Current v0 scope includes a power overlay that traps focus and closes with Back. ## Technology -Bigscreen Mode is built with: +Bigscreen Mode is a **native Qt application**, not a web shell. -* Tauri -* HTML -* CSS -* JavaScript -* Rust backend through Tauri -* Web Gamepad API -* Nebula Core adapters +Target stack: + +* Qt 6 +* Qt Quick (QML) for the controller-first UI +* C++ for system integration, library scanning, and Nebula Core adapters +* Qt input APIs for keyboard and gamepad navigation +* CMake for builds + +The repo still contains an early **Tauri/HTML v0 prototype** under `Bigscreen/` (HTML, CSS, JavaScript, and a Rust backend). That prototype validated layout, focus flow, and input actions. New Bigscreen work targets the Qt shell; the Tauri stack is legacy and will be removed as the Qt app reaches parity. --- ## Run -From the root of the repository: +### Qt shell (target) + +Build and run instructions will be added when the Qt project lands in `Bigscreen/`. Expect a standard CMake workflow, for example: + +```bash +cmake -S Bigscreen -B build/bigscreen -DCMAKE_BUILD_TYPE=Debug +cmake --build build/bigscreen +``` + +### Legacy Tauri prototype + +To run the existing v0 web prototype while migration is in progress, from `Bigscreen/`: ```bash npm install @@ -268,15 +326,27 @@ npm run dev ## Build +### Qt shell (target) + +Release builds will use the Qt/CMake project once it is in the tree. + +### Legacy Tauri prototype + ```bash npm run build ``` +Run from `Bigscreen/`. + --- ## Development Notes -Bigscreen Mode is currently developed primarily on Windows for faster UI iteration. +Bigscreen Mode is moving to Qt for a native fullscreen shell, lower overhead, and tighter OS integration (sessions, launching, power controls). + +Login, SDDM, and Plasma session work happen under **Desktop Mode**; Bigscreen assumes the user already chose the Bigscreen session at the OS login screen. + +The Tauri prototype was developed primarily on Windows for fast UI iteration. Qt development should be validated on both Windows and Linux early. Linux testing is still required for: @@ -295,7 +365,7 @@ Linux testing is still required for: Bigscreen Mode is successful when: * The entire interface works with a controller -* Users can unlock the system +* Users arrive signed in via the OS login screen (Bigscreen does not gate access) * Users can navigate Home * Users can open Library * Users can open Settings diff --git a/Desktop/README-Desktop.md b/Desktop/README-Desktop.md index 1715a38..1a323af 100644 --- a/Desktop/README-Desktop.md +++ b/Desktop/README-Desktop.md @@ -120,12 +120,23 @@ Desktop Mode is currently in the early KDE customization stage. * [ ] Nebula Browser desktop shortcut * [ ] Cleaner apply and reload scripts +### Parallel track: OS login (controller-friendly) + +Desktop Mode work now includes a **controller-friendly OS login** so Bigscreen Mode does not need its own account creation, PIN lock, or sign-in flows. + +Planned at the system layer (SDDM + sessions): + +* Nebula SDDM theme navigable with a gamepad +* Account picker and sign-in +* Session choice: Nebula Bigscreen vs Nebula Desktop +* First-run / account setup when needed (desktop or login side, not inside Bigscreen) + +This can proceed alongside Plasma theme work; it does not need to wait until every panel pixel is final. + ### Not the Focus Yet -The following are planned, but should not be the main focus until the base Desktop Mode theme feels solid: +The following are planned, but should not block the base Desktop theme or login track: -* Full custom login system -* Full SDDM theme * Full Nebula Control Center * Nebula Store * Nebula Library desktop app @@ -480,25 +491,28 @@ Definition of done: ## Milestone 4: Login, Session, and System Polish v0.4 -Status: Future +Status: Planned (parallel with theme milestones) -Goal: Make Desktop Mode feel more native from boot/login onward. +Goal: Provide a **controller-friendly OS login** so users pick account and session before Bigscreen or Desktop starts. Bigscreen Mode should not implement account creation or login. Tasks: -* [ ] Create SDDM theme +* [ ] Create controller-friendly SDDM theme +* [ ] Account picker and sign-in usable with gamepad and keyboard +* [ ] Session entries: Nebula Bigscreen and Nebula Desktop +* [ ] First-run / account setup flow (OS or desktop side, not in Bigscreen shell) * [ ] Create splash screen -* [ ] Create lock screen styling -* [ ] Add NebulaOS Desktop session entry -* [ ] Add Bigscreen session entry +* [ ] Optional lock/suspend styling consistent with SDDM (session layer, not Bigscreen PIN) * [ ] Add desktop-to-bigscreen switch flow * [ ] Add bigscreen-to-desktop switch flow -* [ ] Improve power menu integration +* [ ] Log out / switch user returns to SDDM +* [ ] Improve power menu integration in Bigscreen (return to login only) Definition of done: +* Users can sign in and choose Bigscreen or Desktop from the couch with a controller +* Bigscreen Qt shell starts already authenticated—no in-shell login or account wizard * Desktop Mode feels connected from login to desktop -* The user can choose or switch sessions cleanly * NebulaOS feels less like a theme and more like an operating system experience --- diff --git a/README.md b/README.md index 43ad461..f70eafb 100644 --- a/README.md +++ b/README.md @@ -58,11 +58,11 @@ It is designed for: * Profiles * Media-focused workflows -Bigscreen Mode is built as a fullscreen Nebula shell using Tauri, HTML, CSS, JavaScript, and a controller-first navigation system. +Bigscreen Mode is becoming a native Qt shell; the repo still contains a Tauri/HTML v0 prototype for early UI work. Sign-in and session choice happen at the OS login screen, not inside Bigscreen. Current v0 features include: -* Lock screen with controller and keyboard PIN keypad +* Lock screen with PIN keypad in the Tauri prototype only (OS login replaces this in the target design) * Home dashboard tile grid * Library screen * Settings screen @@ -169,11 +169,13 @@ NebulaOS │ ├── Nebula Library │ ├── Controller Settings │ ├── Power Menu -│ └── Profile / Lock Screen +│ └── Profile status (signed-in user; no OS login) │ ├── Desktop Mode │ ├── KDE Plasma │ ├── Nebula desktop theme +│ ├── Controller-friendly SDDM login +│ ├── Session entries (Bigscreen / Desktop) │ ├── Desktop apps │ └── Advanced system tools │ @@ -244,7 +246,7 @@ Current features include: * Tauri frontend shell * Controller and keyboard input mapping -* Lock screen +* Tauri prototype lock screen (superseded by planned OS login) * Home dashboard * Library stub * Settings stub @@ -254,7 +256,7 @@ Current features include: * 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. +The project is building **Bigscreen Mode** (Qt shell) and **Desktop Mode** (KDE Plasma customization) in parallel. A controller-friendly **OS login** (SDDM + sessions) is part of Desktop/system work so Bigscreen does not handle account creation or sign-in. --- @@ -397,7 +399,7 @@ Used for: * UI development * Controller navigation -* Lock screen work +* Bigscreen UI prototyping (legacy Tauri lock screen is not target architecture) * Library UI * Settings UI * Frontend architecture @@ -424,49 +426,50 @@ Test OS-level behavior in Linux. ## Roadmap -### Phase 1: Bigscreen Shell +### Phase 1: Desktop Mode and OS login (in progress) -Goal: Build a polished controller-first shell. +Goal: Build the KDE-based desktop layer and a controller-friendly login experience. Deliverables: -* Lock screen -* Home dashboard -* Library screen -* Settings screen -* Power menu -* Controller navigation -* Fullscreen mode -* Basic app launching - ---- - -### Phase 2: Desktop Mode Foundation - -Goal: Create the NebulaOS desktop environment experience. - -Deliverables: - -* KDE Plasma setup -* Nebula theme -* SDDM login configuration -* Bigscreen and Desktop session entries -* Desktop-to-Bigscreen switching +* KDE Plasma Nebula theme and look-and-feel +* Controller-friendly SDDM login (account picker, sign-in) +* Nebula Bigscreen and Nebula Desktop session entries +* First-run / account setup at the OS layer (not inside Bigscreen) +* Desktop-to-Bigscreen and Bigscreen-to-Desktop switching * Basic Nebula desktop tools --- -### Phase 3: Session Integration +### Phase 2: Bigscreen Qt shell -Goal: Make NebulaOS feel like a real OS experience. +Goal: Build a polished controller-first game shell that starts after OS login. Deliverables: -* Bigscreen session selectable from login -* Desktop session selectable from login -* Bigscreen launches fullscreen -* Exit to desktop or login -* Controller works reliably in Bigscreen Mode +* Native Qt/QML Bigscreen app +* Home dashboard +* Library screen +* Settings screen +* Power menu (including log out to OS login) +* Controller navigation +* Fullscreen mode +* Basic app launching + +Bigscreen does **not** deliver in-shell login, PIN lock, or account creation. + +--- + +### Phase 3: Session polish + +Goal: Make NebulaOS feel like a real OS from boot to shell. + +Deliverables: + +* Reliable gamepad support on SDDM and in Bigscreen +* Bigscreen launches fullscreen into the signed-in session +* Exit to desktop or return to login +* Consistent Nebula visual identity across login, Bigscreen, and Desktop --- @@ -508,7 +511,7 @@ NebulaOS v0 is successful when: * Bigscreen Mode can be launched fullscreen * The entire shell is controller navigable -* The lock screen works +* OS login works with controller and keyboard (SDDM; not an in-Bigscreen lock screen) * The Home dashboard works * The Library can display and launch local entries * Settings has a usable controller-first structure