Add rog-control-center to the workspace

2026-01-22 17:33:19 +01:00 · 2022-07-25 15:57:05 +12:00
parent 808a1d2470
commit 17df3cf01d
30 changed files with 7124 additions and 23 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

 ## [Unreleased ]
+### Added
+- `rog-control-center` has now been moved in to the main workspace due to
+  the heavy dependencies on most of the rog crates
+

 ## [4.3.0] - 2022-07-21
 ### Added
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace]
-members = ["asusctl", "asus-notify", "daemon", "daemon-user", "rog-supported", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles"]
+members = ["asusctl", "asus-notify", "daemon", "daemon-user", "rog-supported", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center"]

 [profile.release]
 # thin = 57s, asusd = 9.0M
--- a/9
+++ b/9
@@ -11,6 +11,7 @@ datarootdir = $(prefix)/share
 libdir = $(exec_prefix)/lib
 zshcpl = $(datarootdir)/zsh/site-functions

+BIN_ROG := rog-control-center
 BIN_C := asusctl
 BIN_D := asusd
 BIN_U := asusd-user
@@ -39,6 +40,10 @@ distclean:
 	rm -rf .cargo vendor vendor.tar.xz

 install:
+	$(INSTALL_PROGRAM) "./target/release/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).desktop" "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
+	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
+
 	$(INSTALL_PROGRAM) "./target/release/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
 	$(INSTALL_PROGRAM) "./target/release/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
 	$(INSTALL_PROGRAM) "./target/release/$(BIN_U)" "$(DESTDIR)$(bindir)/$(BIN_U)"
@@ -68,6 +73,10 @@ install:
 	cd rog-anime/data && find "./anime" -type f -exec install -Dm 755 "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;

 uninstall:
+	rm -f "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+	rm -r "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
+
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_C)"
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_D)"
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_N)"
--- a/README.md
+++ b/README.md
@@ -5,6 +5,8 @@
 `asusd` is a utility for Linux to control many aspects of various ASUS laptops
 but can also be used with non-asus laptops with reduced features.

+Now includes a GUI, `rog-control-center`.
+
 ## Kernel support

 **The minimum supported kernel version is 5.15**
--- a/rog-control-center/.vscode/configurationCache.log
+++ b/rog-control-center/.vscode/configurationCache.log
@@ -0,0 +1 @@
+{"buildTargets":["all","build","clean","distclean","install","uninstall","update","vendor"],"launchTargets":[],"customConfigurationProvider":{"workspaceBrowse":{"browsePath":[],"compilerArgs":[]},"fileIndex":[]}}
--- a/rog-control-center/.vscode/dryrun.log
+++ b/rog-control-center/.vscode/dryrun.log
@@ -0,0 +1,6 @@
+make --dry-run --always-make --keep-going --print-directory
+make: Entering directory '/home/luke/Projects/rog-control-center'
+ 
+cargo build --release
+make: Leaving directory '/home/luke/Projects/rog-control-center'
+ 
--- a/rog-control-center/.vscode/settings.json
+++ b/rog-control-center/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+    "makefile.extensionOutputFolder": "./.vscode"
+}
--- a/rog-control-center/.vscode/targets.log
+++ b/rog-control-center/.vscode/targets.log
@@ -0,0 +1,414 @@
+make all --print-data-base --no-builtin-variables --no-builtin-rules --question
+# GNU Make 4.3
+# Built for x86_64-redhat-linux-gnu
+# Copyright (C) 1988-2020 Free Software Foundation, Inc.
+# License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+# Make data base, printed on Mon Jul 25 13:56:15 2022
+
+# Variables
+
+# makefile (from 'Makefile', line 4)
+INSTALL_PROGRAM = ${INSTALL} -D -m 0755
+# environment
+GDK_BACKEND = x11
+# environment
+LC_ALL = C
+# environment
+NO_AT_BRIDGE = 1
+# makefile (from 'Makefile', line 15)
+SRC := Cargo.toml Cargo.lock Makefile ./src/error.rs ./src/config.rs ./src/widgets/mod.rs ./src/widgets/top_bar.rs ./src/widgets/side_panel.rs ./src/widgets/anime_page.rs ./src/widgets/aura_page.rs ./src/widgets/fan_curve_page.rs ./src/widgets/system_page.rs ./src/app.rs ./src/lib.rs ./src/main.rs ./src/notify.rs ./src/page_states.rs
+# environment
+STARSHIP_SESSION_KEY = 2042530886117081
+# environment
+GJS_DEBUG_OUTPUT = stderr
+# environment
+VSCODE_CWD = /home/luke
+# makefile (from 'Makefile', line 7)
+prefix = /usr
+# environment
+GDM_LANG = en_NZ.UTF-8
+# environment
+WASMER_DIR = /home/luke/.wasmer
+# default
+MAKE_COMMAND := make
+# environment
+define BASH_FUNC_which%%
+() {  ( alias;
+ eval ${which_declare} ) | /usr/bin/which --tty-only --read-alias --read-functions --show-tilde --show-dot $@
+}
+endef
+# automatic
+@D = $(patsubst %/,%,$(dir $@))
+# environment
+VSCODE_HANDLES_UNCAUGHT_ERRORS = true
+# makefile (from 'Makefile', line 13)
+BIN_ROG := rog-control-center
+# default
+.VARIABLES := 
+# environment
+PWD = /home/luke/Projects/rog-control-center
+# automatic
+%D = $(patsubst %/,%,$(dir $%))
+# environment
+HOSTNAME = fedora
+# environment
+MAIL = /var/spool/mail/luke
+# environment
+STEAM_FRAME_FORCE_CLOSE = 1
+# environment
+XDG_DATA_DIRS = /home/luke/.local/share/flatpak/exports/share:/var/lib/flatpak/exports/share:/usr/local/share/:/usr/share/
+# automatic
+^D = $(patsubst %/,%,$(dir $^))
+# automatic
+%F = $(notdir $%)
+# environment
+VSCODE_CODE_CACHE_PATH = /home/luke/.config/Code/CachedData/3b889b090b5ad5793f524b5d1d39fda662b96a2a
+# environment
+LANG = C
+# environment
+XAUTHORITY = /run/user/1000/.mutter-Xwaylandauth.WG1MP1
+# default
+.LOADED := 
+# default
+.INCLUDE_DIRS = /usr/include /usr/local/include /usr/include
+# makefile
+MAKEFLAGS = pqrR
+# makefile
+CURDIR := /home/luke/Projects/rog-control-center
+# environment
+APPLICATION_INSIGHTS_NO_DIAGNOSTIC_CHANNEL = true
+# environment
+LESSOPEN = ||/usr/bin/lesspipe.sh %s
+# automatic
+*D = $(patsubst %/,%,$(dir $*))
+# makefile (from 'Makefile', line 1)
+VERSION := 0.1.2
+# environment
+MFLAGS = -pqrR
+# environment
+SSH_AUTH_SOCK = /run/user/1000/keyring/ssh
+# default
+.SHELLFLAGS := -c
+# environment
+WAYLAND_DISPLAY = wayland-0
+# environment
+HISTSIZE = 1000
+# automatic
+D = $(patsubst %/,%,$(dir $+))
+# environment
+XDG_SESSION_DESKTOP = gnome
+# makefile (from 'Makefile', line 1)
+MAKEFILE_LIST := Makefile
+# automatic
+@F = $(notdir $@)
+# environment
+VSCODE_PID = 152272
+# environment
+SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS = 0
+# environment
+XDG_SESSION_TYPE = wayland
+# automatic
+?D = $(patsubst %/,%,$(dir $?))
+# makefile (from 'Makefile', line 3)
+INSTALL = install
+# environment
+SESSION_MANAGER = local/unix:@/tmp/.ICE-unix/1985,unix/unix:/tmp/.ICE-unix/1985
+# automatic
+*F = $(notdir $*)
+# makefile (from 'Makefile', line 23)
+VENDORED = 0
+# environment
+CHROME_DESKTOP = code-url-handler.desktop
+# environment
+DBUS_SESSION_BUS_ADDRESS = unix:path=/run/user/1000/bus
+# automatic
+<D = $(patsubst %/,%,$(dir $<))
+# environment
+VSCODE_NLS_CONFIG = {"locale":"en-gb","availableLanguages":{},"_languagePackSupport":true}
+# environment
+ANDROID_SDK_ROOT = /home/luke/Android/Sdk
+# default
+MAKE_HOST := x86_64-redhat-linux-gnu
+# makefile
+SHELL = /bin/sh
+# default
+MAKECMDGOALS := all
+# environment
+XMODIFIERS = @im=ibus
+# environment
+GJS_DEBUG_TOPICS = JS ERROR;JS LOG
+# environment
+SHLVL = 0
+# makefile (from 'Makefile', line 19)
+ARGS = --release
+# environment
+GCC_COLORS = error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01
+# environment
+MAKELEVEL := 0
+# default
+MAKE = $(MAKE_COMMAND)
+# environment
+PATH = /home/luke/Android/Sdk/tools/bin:/home/luke/Android/Sdk/tools:/home/luke/Android/flutter/bin:/home/luke/.wasmer/bin:/home/luke/Android/Sdk/tools/bin:/home/luke/Android/Sdk/tools:/home/luke/Android/flutter/bin:/home/luke/Android/Sdk/tools/bin:/home/luke/Android/Sdk/tools:/home/luke/Android/flutter/bin:/home/luke/.wasmer/bin:/home/luke/Android/Sdk/tools/bin:/home/luke/Android/Sdk/tools:/home/luke/Android/flutter/bin:/home/luke/.cargo/bin:/home/luke/.local/bin:/home/luke/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/home/luke/.wasmer/globals/wapm_packages/.bin:/home/luke/.wasmer/globals/wapm_packages/.bin
+# default
+MAKEFILES := 
+# automatic
+^F = $(notdir $^)
+# makefile (from 'Makefile', line 9)
+bindir = $(exec_prefix)/bin
+# makefile (from 'Makefile', line 10)
+datarootdir = $(prefix)/share
+# environment
+INVOCATION_ID = 2eaec57f907246ed918d02a60be4d129
+# environment
+USERNAME = luke
+# environment
+GNOME_SETUP_DISPLAY = :1
+# makefile (from 'Makefile', line 8)
+exec_prefix = $(prefix)
+# automatic
+?F = $(notdir $?)
+# environment
+XDG_CURRENT_DESKTOP = GNOME
+# environment
+LS_COLORS = 
+# automatic
+F = $(notdir $+)
+# environment
+DESKTOP_SESSION = gnome
+# environment
+WASMER_CACHE_DIR = /home/luke/.wasmer/cache
+# environment
+ORIGINAL_XDG_CURRENT_DESKTOP = GNOME
+# 'override' directive
+GNUMAKEFLAGS := 
+# environment
+LOGNAME = luke
+# environment
+GIO_LAUNCHED_DESKTOP_FILE = /usr/share/applications/code.desktop
+# makefile
+.DEFAULT_GOAL := all
+# environment
+SYSTEMD_EXEC_PID = 2026
+# environment
+HISTCONTROL = ignoreboth:erasedups
+# environment
+EDITOR = vim
+# environment
+DISPLAY = :0
+# environment
+USER = luke
+# default
+MAKE_VERSION := 4.3
+# 'override' directive
+.SHELLSTATUS := 0
+# environment
+MANAGERPID = 1828
+# environment
+which_declare = declare -f
+# environment
+DEBUGINFOD_URLS = https://debuginfod.fedoraproject.org/ 
+# environment
+STARSHIP_SHELL = bash
+# environment
+GIO_LAUNCHED_DESKTOP_FILE_PID = 152272
+# environment
+BAT_THEME = Monokai Extended Light
+# environment
+_ = /usr/bin/make
+# environment
+ANDROID_NDK_ROOT = /home/luke/Android/Sdk/ndk/24.0.8215888
+# environment
+XDG_RUNTIME_DIR = /run/user/1000
+# environment
+JOURNAL_STREAM = 8:32224
+# environment
+XDG_SESSION_CLASS = user
+# environment
+VSCODE_AMD_ENTRYPOINT = vs/workbench/api/node/extensionHostProcess
+# environment
+HOME = /home/luke
+# environment
+QT_IM_MODULE = ibus
+# makefile (from 'Makefile', line 5)
+INSTALL_DATA = ${INSTALL} -D -m 0644
+# environment
+ELECTRON_RUN_AS_NODE = 1
+# environment
+VSCODE_IPC_HOOK = /run/user/1000/vscode-8b1d6e5b-1.69.2-main.sock
+# default
+.RECIPEPREFIX := 
+# automatic
+<F = $(notdir $<)
+# default
+SUFFIXES := 
+# makefile (from 'Makefile', line 20)
+TARGET = release
+# makefile (from 'Makefile', line 11)
+libdir = $(exec_prefix)/lib
+# makefile (from 'Makefile', line 17)
+DEBUG = 0
+# default
+.FEATURES := target-specific order-only second-expansion else-if shortest-stem undefine oneshell nocomment grouped-target extra-prereqs archives jobserver output-sync check-symlink guile load
+# environment
+XDG_MENU_PREFIX = gnome-
+# environment
+GDMSESSION = gnome
+# variable set hash-table stats:
+# Load=121/1024=12%, Rehash=0, Collisions=9/168=5%
+
+# Pattern-specific Variable Values
+
+# No pattern-specific variable values.
+
+# Directories
+
+# . (device 41, inode 1835231): 16 files, no impossibilities.
+
+# 16 files, no impossibilities in 1 directories.
+
+# Implicit Rules
+
+# No implicit rules.
+
+# Files
+
+distclean:
+#  Phony target (prerequisite of .PHONY).
+#  Implicit rule search has not been done.
+#  File does not exist.
+#  File has not been updated.
+#  recipe to execute (from 'Makefile', line 34):
+	rm -rf .cargo vendor vendor.tar.xz
+
+update:
+#  Phony target (prerequisite of .PHONY).
+#  Implicit rule search has not been done.
+#  File does not exist.
+#  File has not been updated.
+#  recipe to execute (from 'Makefile', line 47):
+	cargo update
+
+# Not a target:
+Makefile:
+#  Implicit rule search has been done.
+ 
+#  Last modified 2022-07-24 15:01:20.244889065
+#  File has been updated.
+#  Successfully updated.
+
+vendor:
+#  Implicit rule search has not been done.
+#  Modification time never checked.
+#  File has not been updated.
+#  recipe to execute (from 'Makefile', line 50):
+	mkdir -p .cargo
+	cargo vendor | head -n -1 > .cargo/config
+	echo 'directory = "vendor"' >> .cargo/config
+	mv .cargo/config ./cargo-config
+	rm -rf .cargo
+	tar pcfJ vendor_asusctl_$(VERSION).tar.xz vendor
+	rm -rf vendor
+
+uninstall:
+#  Phony target (prerequisite of .PHONY).
+#  Implicit rule search has not been done.
+#  File does not exist.
+#  File has not been updated.
+#  recipe to execute (from 'Makefile', line 42):
+	rm -f "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+	rm -r "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
+
+clean:
+#  Phony target (prerequisite of .PHONY).
+#  Implicit rule search has not been done.
+#  File does not exist.
+#  File has not been updated.
+#  recipe to execute (from 'Makefile', line 31):
+	cargo clean
+
+# Not a target:
+.DEFAULT:
+#  Implicit rule search has not been done.
+#  Modification time never checked.
+#  File has not been updated.
+
+all: build
+#  Phony target (prerequisite of .PHONY).
+#  Command line target.
+#  Implicit rule search has not been done.
+#  File does not exist.
+#  File has been updated.
+#  Needs to be updated (-q is set).
+# variable set hash-table stats:
+# Load=0/32=0%, Rehash=0, Collisions=0/4=0%
+
+build:
+#  Phony target (prerequisite of .PHONY).
+#  Implicit rule search has not been done.
+#  Implicit/static pattern stem: ''
+#  File does not exist.
+#  File has been updated.
+#  Needs to be updated (-q is set).
+# automatic
+# @ := build
+# automatic
+# * := 
+# automatic
+# < := 
+# automatic
+# + := 
+# automatic
+# % := 
+# automatic
+# ^ := 
+# automatic
+# ? := 
+# automatic
+# | := 
+# variable set hash-table stats:
+# Load=8/32=25%, Rehash=0, Collisions=6/12=50%
+#  recipe to execute (from 'Makefile', line 63):
+	cargo build $(ARGS)
+
+install:
+#  Phony target (prerequisite of .PHONY).
+#  Implicit rule search has not been done.
+#  File does not exist.
+#  File has not been updated.
+#  recipe to execute (from 'Makefile', line 37):
+	$(INSTALL_PROGRAM) "./target/release/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+	$(INSTALL_DATA) "./data/$(BIN_ROG).desktop" "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
+	$(INSTALL_DATA) "./data/$(BIN_ROG).png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
+
+# Not a target:
+.SUFFIXES:
+#  Implicit rule search has not been done.
+#  Modification time never checked.
+#  File has not been updated.
+
+.PHONY: all clean distclean install uninstall update build
+#  Implicit rule search has not been done.
+#  Modification time never checked.
+#  File has not been updated.
+
+# files hash-table stats:
+# Load=12/1024=1%, Rehash=0, Collisions=0/33=0%
+# VPATH Search Paths
+
+# No 'vpath' search paths.
+
+# No general ('VPATH' variable) search path.
+
+# strcache buffers: 1 (0) / strings = 29 / storage = 279 B / avg = 9 B
+# current buf: size = 8162 B / used = 279 B / count = 29 / avg = 9 B
+
+# strcache performance: lookups = 52 / hit rate = 44%
+# hash-table stats:
+# Load=29/8192=0%, Rehash=0, Collisions=0/52=0%
+# Finished Make data base on Mon Jul 25 13:56:15 2022
+
+ 
--- a/rog-control-center/Cargo.lock
+++ b/rog-control-center/Cargo.lock
--- a/rog-control-center/Cargo.toml
+++ b/rog-control-center/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+name = "rog-control-center"
+version = "0.1.3"
+authors = ["Luke D. Jones <luke@ljones.dev>"]
+edition = "2021"
+
+[features]
+mocking = []
+
+[dependencies]
+egui = { git = "https://github.com/emilk/egui" }
+eframe= { git = "https://github.com/emilk/egui" }
+#eframe= { git = "https://github.com/emilk/egui", default-features = false, features = ["dark-light", "default_fonts", "wgpu"] }
+
+rog_dbus = { path = "../rog-dbus" }
+rog_aura = { path = "../rog-aura" }
+rog_profiles = { path = "../rog-profiles" }
+rog_supported = { path = "../rog-supported" }
+# supergfxctl = { git = "https://gitlab.com/asus-linux/supergfxctl.git" }
+
+smol = "^1.2"
+
+serde = "^1.0"
+toml = "^0.5"
+serde_json = "^1.0"
+serde_derive = "^1.0"
+zbus = "^2.3"
+nix = "^0.20.0"
+tempfile = "3.2.0"
+dirs = "3.0.1"
+
+[dependencies.notify-rust]
+version = "^4.3"
+default-features = false
+features = ["z"]
+
+[profile.release]
+lto = true
+debug = false
+opt-level = 3
+panic = "abort"
+
+[profile.bench]
+debug = false
+opt-level = 3
--- a/rog-control-center/LICENSE
+++ b/rog-control-center/LICENSE
@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.
--- a/rog-control-center/Makefile
+++ b/rog-control-center/Makefile
@@ -0,0 +1,65 @@
+VERSION := $(shell grep -Pm1 'version = "(\d.\d.\d)"' Cargo.toml | cut -d'"' -f2)
+
+INSTALL = install
+INSTALL_PROGRAM = ${INSTALL} -D -m 0755
+INSTALL_DATA = ${INSTALL} -D -m 0644
+
+prefix = /usr
+exec_prefix = $(prefix)
+bindir = $(exec_prefix)/bin
+datarootdir = $(prefix)/share
+libdir = $(exec_prefix)/lib
+
+BIN_ROG := rog-control-center
+
+SRC := Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
+
+DEBUG ?= 0
+ifeq ($(DEBUG),0)
+	ARGS += --release
+	TARGET = release
+endif
+
+VENDORED ?= 0
+ifeq ($(VENDORED),1)
+	ARGS += --frozen
+endif
+
+all: build
+
+clean:
+	cargo clean
+
+distclean:
+	rm -rf .cargo vendor vendor.tar.xz
+
+install:
+	$(INSTALL_PROGRAM) "./target/release/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+	$(INSTALL_DATA) "./data/$(BIN_ROG).desktop" "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
+	$(INSTALL_DATA) "./data/$(BIN_ROG).png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
+
+uninstall:
+	rm -f "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+	rm -r "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
+
+update:
+	cargo update
+
+vendor:
+	mkdir -p .cargo
+	cargo vendor | head -n -1 > .cargo/config
+	echo 'directory = "vendor"' >> .cargo/config
+	mv .cargo/config ./cargo-config
+	rm -rf .cargo
+	tar pcfJ vendor_asusctl_$(VERSION).tar.xz vendor
+	rm -rf vendor
+
+build:
+ifeq ($(VENDORED),1)
+	@echo "version = $(VERSION)"
+	tar pxf vendor_asusctl_$(VERSION).tar.xz
+endif
+	cargo build $(ARGS)
+
+.PHONY: all clean distclean install uninstall update build
--- a/rog-control-center/README.md
+++ b/rog-control-center/README.md
@@ -0,0 +1,22 @@
+# App template
+
+This is a trial app cut down to bare essentials to show how to create an app that can run in the background
+with some user-config options.
+
+egui based. Keep in mind that this is very much a bit of a mess due to experimenting.
+
+## Running
+
+Use `WINIT_UNIX_BACKEND=x11 rog-control-center`. `WINIT_UNIX_BACKEND` is required due to window decorations not updating and the window not really being set as visible/invisible on wayland.
+
+## Build features
+
+For testing some features that are typically not available on all laptops:
+
+```rust
+cargo run --features mocking
+```
+
+## TODO
+
+- Add notification watch for certain UI elements to enforce an update (for example when a user changes Aura via a hot key).
--- a/rog-control-center/data/rog-control-center.desktop
+++ b/rog-control-center/data/rog-control-center.desktop
@@ -0,0 +1,11 @@
+[Desktop Entry]
+Version=1.0
+Type=Application
+
+Name=ROG Control Center
+Comment=Make your ASUS ROG Laptop go Brrrrr!
+Categories=Settings
+
+Icon=rog-control-center
+Exec=env WINIT_UNIX_BACKEND=x11 rog-control-center
+Terminal=false
--- a/rog-control-center/data/rog-control-center.png
+++ b/rog-control-center/data/rog-control-center.png
--- a/rog-control-center/src/app.rs
+++ b/rog-control-center/src/app.rs
@@ -0,0 +1,127 @@
+use std::{
+    io::Write,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    time::Duration,
+};
+
+use egui::{Button, RichText};
+use rog_dbus::RogDbusClientBlocking;
+use rog_supported::SupportedFunctions;
+
+use crate::{config::Config, get_ipc_file, page_states::PageDataStates, Page, SHOWING_GUI};
+
+pub struct RogApp<'a> {
+    pub page: Page,
+    pub states: PageDataStates,
+    pub supported: SupportedFunctions,
+    /// Should the app begin showing the GUI
+    pub begin_show_gui: Arc<AtomicBool>,
+    /// Is the app GUI closed (and running in bg)
+    pub running_in_bg: bool,
+    // TODO: can probably just open and read whenever
+    pub config: Config,
+    pub asus_dbus: RogDbusClientBlocking<'a>,
+}
+
+impl<'a> RogApp<'a> {
+    /// Called once before the first frame.
+    pub fn new(
+        start_closed: bool,
+        config: Config,
+        show_gui: Arc<AtomicBool>,
+        states: PageDataStates,
+        _cc: &eframe::CreationContext<'_>,
+    ) -> Self {
+        let (dbus, _) = RogDbusClientBlocking::new().unwrap();
+        let supported = dbus.proxies().supported().supported_functions().unwrap();
+
+        Self {
+            supported,
+            states,
+            page: Page::System,
+            begin_show_gui: show_gui,
+            running_in_bg: start_closed,
+            config,
+            asus_dbus: dbus,
+        }
+    }
+}
+
+impl<'a> eframe::App for RogApp<'a> {
+    fn on_exit_event(&mut self) -> bool {
+        if self.config.run_in_background {
+            self.running_in_bg = true;
+            get_ipc_file().unwrap().write_all(&[0]).unwrap();
+            return false;
+        }
+        true
+    }
+
+    /// Called each time the UI needs repainting, which may be many times per second.
+    /// Put your widgets into a `SidePanel`, `TopPanel`, `CentralPanel`, `Window` or `Area`.
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        let Self {
+            begin_show_gui: should_show_gui,
+            supported,
+            asus_dbus: dbus,
+            states,
+            ..
+        } = self;
+        if states.refresh_if_notfied(supported, dbus) {
+            ctx.request_repaint();
+        }
+
+        let page = self.page;
+
+        if should_show_gui.load(Ordering::SeqCst) {
+            let mut ipc_file = get_ipc_file().unwrap();
+            ipc_file.write_all(&[SHOWING_GUI]).unwrap();
+            should_show_gui.store(false, Ordering::SeqCst);
+            frame.set_visible(true);
+            self.running_in_bg = false;
+        }
+        if self.running_in_bg {
+            // Request to draw nothing at all
+            ctx.request_repaint_after(Duration::from_millis(500));
+            frame.set_visible(false);
+            return;
+        }
+        // Do all GUI display after this point
+
+        self.top_bar(ctx, frame);
+        self.side_panel(ctx);
+
+        if let Some(err) = self.states.error.clone() {
+            egui::CentralPanel::default().show(ctx, |ui| {
+                ui.heading(RichText::new("Error!").size(28.0));
+
+                ui.centered_and_justified(|ui| {
+                    ui.label(RichText::new(format!("The error was: {:?}", err)).size(22.0));
+                });
+            });
+            egui::TopBottomPanel::bottom("error_bar")
+                .default_height(26.0)
+                .show(ctx, |ui| {
+                    ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
+                        if ui
+                            .add(Button::new(RichText::new("Okay").size(20.0)))
+                            .clicked()
+                        {
+                            self.states.error = None;
+                        }
+                    });
+                });
+        } else if page == Page::System {
+            self.system_page(ctx);
+        } else if page == Page::AuraEffects {
+            self.aura_page(ctx);
+        } else if page == Page::AnimeMatrix {
+            self.anime_page(ctx);
+        } else if page == Page::FanCurves {
+            self.fan_curve_page(ctx);
+        }
+    }
+}
--- a/rog-control-center/src/config.rs
+++ b/rog-control-center/src/config.rs
@@ -0,0 +1,92 @@
+use std::{
+    fs::{create_dir, OpenOptions},
+    io::{Read, Write},
+};
+
+use serde_derive::{Deserialize, Serialize};
+//use log::{error, info, warn};
+
+use crate::error::Error;
+
+const CFG_DIR: &str = "rog";
+const CFG_FILE_NAME: &str = "app-template.cfg";
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(default)]
+pub struct Config {
+    pub run_in_background: bool,
+    pub startup_in_background: bool,
+    pub enable_notifications: bool,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            run_in_background: true,
+            startup_in_background: false,
+            enable_notifications: true,
+        }
+    }
+}
+
+impl Config {
+    pub fn load() -> Result<Config, Error> {
+        let mut path = if let Some(dir) = dirs::config_dir() {
+            dir
+        } else {
+            return Err(Error::XdgVars);
+        };
+
+        path.push(CFG_DIR);
+        if !path.exists() {
+            create_dir(path.clone())?;
+        }
+
+        path.push(CFG_FILE_NAME);
+
+        let mut file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(&path)?;
+
+        let mut buf = String::new();
+
+        if let Ok(read_len) = file.read_to_string(&mut buf) {
+            if read_len == 0 {
+                let default = Config::default();
+                let t = toml::to_string_pretty(&default).unwrap();
+                file.write_all(t.as_bytes())?;
+                return Ok(default);
+            } else if let Ok(data) = toml::from_str::<Config>(&buf) {
+                return Ok(data);
+            }
+        }
+        Err(Error::ConfigLoadFail)
+    }
+
+    pub fn save(&self) -> Result<(), Error> {
+        let mut path = if let Some(dir) = dirs::config_dir() {
+            dir
+        } else {
+            return Err(Error::XdgVars);
+        };
+
+        path.push(CFG_DIR);
+        if !path.exists() {
+            create_dir(path.clone())?;
+        }
+
+        path.push(CFG_FILE_NAME);
+
+        let mut file = OpenOptions::new()
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(&path)?;
+
+        let t = toml::to_string_pretty(&self).unwrap();
+        file.write_all(t.as_bytes())?;
+        Ok(())
+    }
+}
--- a/rog-control-center/src/error.rs
+++ b/rog-control-center/src/error.rs
@@ -0,0 +1,43 @@
+use std::fmt;
+
+#[derive(Debug)]
+pub enum Error {
+    Io(std::io::Error),
+    Nix(nix::Error),
+    ConfigLoadFail,
+    ConfigLockFail,
+    XdgVars,
+}
+
+impl fmt::Display for Error {
+    // This trait requires `fmt` with this exact signature.
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Error::Io(err) => write!(f, "Failed to open: {}", err),
+            Error::Nix(err) => write!(f, "Error: {}", err),
+            Error::ConfigLoadFail => write!(f, "Failed to load user config"),
+            Error::ConfigLockFail => write!(f, "Failed to lock user config"),
+            Error::XdgVars => write!(f, "XDG environment vars appear unset"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Self {
+        Error::Io(err)
+    }
+}
+
+impl From<Error> for zbus::fdo::Error {
+    fn from(err: Error) -> Self {
+        zbus::fdo::Error::Failed(format!("Anime zbus error: {}", err))
+    }
+}
+
+impl From<nix::Error> for Error {
+    fn from(err: nix::Error) -> Self {
+        Error::Nix(err)
+    }
+}
--- a/rog-control-center/src/lib.rs
+++ b/rog-control-center/src/lib.rs
@@ -0,0 +1,77 @@
+pub mod app;
+use std::{
+    fs::{remove_dir_all, File, OpenOptions},
+    io::{Read, Write},
+    process::exit,
+    thread::sleep,
+    time::Duration,
+};
+
+pub use app::RogApp;
+
+pub mod config;
+pub mod error;
+pub mod notify;
+pub mod page_states;
+pub mod widgets;
+
+use nix::{sys::stat, unistd};
+use tempfile::TempDir;
+//use log::{error, info, warn};
+
+pub const SHOWING_GUI: u8 = 1;
+pub const SHOW_GUI: u8 = 2;
+
+#[derive(PartialEq, Clone, Copy)]
+pub enum Page {
+    System,
+    AuraEffects,
+    AnimeMatrix,
+    FanCurves,
+}
+
+/// Either exit the process, or return with a refreshed tmp-dir
+pub fn on_tmp_dir_exists() -> Result<TempDir, std::io::Error> {
+    let mut buf = [0u8; 4];
+    let path = std::env::temp_dir().join("rog-gui");
+
+    let mut ipc_file = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(false)
+        .open(path.join("ipc.pipe"))?;
+
+    // If the app is running this ends up stacked on top of SHOWING_GUI
+    ipc_file.write_all(&[SHOW_GUI])?;
+    // tiny sleep to give the app a chance to respond
+    sleep(Duration::from_millis(10));
+    ipc_file.read(&mut buf).ok();
+
+    // First entry is the actual state
+    if buf[0] == SHOWING_GUI {
+        ipc_file.write_all(&[SHOWING_GUI])?; // Store state again as we drained the fifo
+        exit(0);
+    } else if buf[0] == SHOW_GUI {
+        remove_dir_all(&path)?;
+        return tempfile::Builder::new()
+            .prefix("rog-gui")
+            .rand_bytes(0)
+            .tempdir();
+    }
+    exit(-1);
+}
+
+pub fn get_ipc_file() -> Result<File, crate::error::Error> {
+    let tmp_dir = std::env::temp_dir().join("rog-gui");
+    let fifo_path = tmp_dir.join("ipc.pipe");
+    if let Err(e) = unistd::mkfifo(&fifo_path, stat::Mode::S_IRWXU) {
+        if !matches!(e, nix::Error::Sys(nix::errno::Errno::EEXIST)) {
+            return Err(e)?;
+        }
+    }
+    Ok(OpenOptions::new()
+        .read(true)
+        .write(true)
+        .truncate(true)
+        .open(&fifo_path)?)
+}
--- a/rog-control-center/src/main.rs
+++ b/rog-control-center/src/main.rs
@@ -0,0 +1,94 @@
+use rog_control_center::{
+    config::Config, get_ipc_file, notify::start_notifications, on_tmp_dir_exists,
+    page_states::PageDataStates, RogApp, SHOW_GUI,
+};
+use rog_dbus::RogDbusClientBlocking;
+use std::{
+    io::Read,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    thread::spawn,
+    time::Duration,
+};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Startup
+    let mut config = Config::load()?;
+    let start_closed = config.startup_in_background;
+
+    if config.startup_in_background {
+        config.run_in_background = true;
+        config.save()?;
+    }
+
+    let (dbus, _) = RogDbusClientBlocking::new().unwrap();
+    let supported = dbus.proxies().supported().supported_functions().unwrap();
+    // Cheap method to alert to notifications rather than spinning a thread for each
+    // This is quite different when done in a retained mode app
+    let charge_notified = Arc::new(AtomicBool::new(false));
+    let bios_notified = Arc::new(AtomicBool::new(false));
+    let aura_notified = Arc::new(AtomicBool::new(false));
+    let anime_notified = Arc::new(AtomicBool::new(false));
+    let profiles_notified = Arc::new(AtomicBool::new(false));
+    let fans_notified = Arc::new(AtomicBool::new(false));
+    // TODO: change this to an error instead of the nested unwraps, then use to
+    // display a bare box app with error message.
+    let states = PageDataStates::new(
+        charge_notified.clone(),
+        bios_notified.clone(),
+        aura_notified.clone(),
+        anime_notified.clone(),
+        profiles_notified.clone(),
+        fans_notified.clone(),
+        &supported,
+        &dbus,
+    );
+
+    if config.enable_notifications {
+        start_notifications(
+            charge_notified,
+            bios_notified,
+            aura_notified,
+            anime_notified,
+            profiles_notified,
+            fans_notified,
+        )?;
+    }
+
+    // tmp-dir must live to the end of program life
+    let _tmp_dir = match tempfile::Builder::new()
+        .prefix("rog-gui")
+        .rand_bytes(0)
+        .tempdir()
+    {
+        Ok(tmp) => tmp,
+        Err(_) => on_tmp_dir_exists().unwrap(),
+    };
+
+    let native_options = eframe::NativeOptions {
+        decorated: true,
+        ..Default::default()
+    };
+
+    let should_show_gui = Arc::new(AtomicBool::new(!start_closed));
+    let should = should_show_gui.clone();
+    spawn(move || {
+        // Loop is blocked here until a single byte is read
+        loop {
+            let mut buf = [0u8; 4];
+            if get_ipc_file().unwrap().read(&mut buf).is_ok() && buf[0] == SHOW_GUI {
+                should_show_gui.store(true, Ordering::SeqCst);
+                // Give the starting app a change to read or we'll race it
+                std::thread::sleep(Duration::from_millis(10));
+            }
+        }
+    });
+
+    eframe::run_native(
+        "ROG Control Center",
+        native_options,
+        Box::new(move |cc| Box::new(RogApp::new(start_closed, config, should, states, cc))),
+    );
+}
--- a/rog-control-center/src/notify.rs
+++ b/rog-control-center/src/notify.rs
@@ -0,0 +1,222 @@
+//TODO: a lot of app state refresh depends on this so there needs
+// to be an extra AtomicBool for checking if notifications are enabled
+
+use notify_rust::{Hint, Notification, NotificationHandle};
+use rog_aura::AuraEffect;
+use rog_dbus::{
+    zbus_anime::AnimeProxy, zbus_charge::ChargeProxy, zbus_led::LedProxy,
+    zbus_profile::ProfileProxy, zbus_rogbios::RogBiosProxy,
+};
+use rog_profiles::Profile;
+use smol::{future, Executor};
+use std::{
+    error::Error,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc, Mutex,
+    },
+    thread::spawn,
+};
+use zbus::export::futures_util::StreamExt;
+
+const NOTIF_HEADER: &str = "ROG Control";
+
+macro_rules! notify {
+    ($notifier:ident, $last_notif:ident, $data:expr) => {
+        if let Some(notif) = $last_notif.take() {
+            notif.close();
+        }
+        if let Ok(x) = $notifier($data) {
+            $last_notif.replace(x);
+        }
+    };
+}
+
+macro_rules! base_notification {
+    ($body:expr) => {
+        Notification::new()
+            .summary(NOTIF_HEADER)
+            .body($body)
+            .timeout(2000)
+            .show()
+    };
+}
+
+type SharedHandle = Arc<Mutex<Option<NotificationHandle>>>;
+
+pub fn start_notifications(
+    charge_notified: Arc<AtomicBool>,
+    bios_notified: Arc<AtomicBool>,
+    aura_notified: Arc<AtomicBool>,
+    anime_notified: Arc<AtomicBool>,
+    profiles_notified: Arc<AtomicBool>,
+    _fans_notified: Arc<AtomicBool>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let last_notification: SharedHandle = Arc::new(Mutex::new(None));
+
+    let executor = Executor::new();
+    // BIOS notif
+    let x = last_notification.clone();
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = RogBiosProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_post_boot_sound().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = x.try_lock() {
+                            notify!(do_post_sound_notif, lock, &out.sound());
+                        }
+                        bios_notified.store(true, Ordering::SeqCst);
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
+
+    // Charge notif
+    let x = last_notification.clone();
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = ChargeProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_charge().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = x.try_lock() {
+                            notify!(do_charge_notif, lock, &out.limit);
+                        }
+                        charge_notified.store(true, Ordering::SeqCst);
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
+
+    // Profile notif
+    let x = last_notification.clone();
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = ProfileProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_profile().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = x.try_lock() {
+                            notify!(do_thermal_notif, lock, &out.profile);
+                        }
+                        profiles_notified.store(true, Ordering::SeqCst);
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
+
+    // LED notif
+    let x = last_notification.clone();
+    let a = aura_notified.clone();
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = LedProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_led().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = x.try_lock() {
+                            notify!(do_led_notif, lock, &out.data);
+                        }
+                        a.store(true, Ordering::SeqCst);
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
+
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = LedProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_power_states().await {
+                p.for_each(|e| {
+                    if let Ok(_out) = e.args() {
+                        // if let Ok(ref mut lock) = last_notification.try_lock() {
+                        //     notify!(do_led_notif, lock, &out.data);
+                        // }
+                        aura_notified.store(true, Ordering::SeqCst);
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
+
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = AnimeProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_power_states().await {
+                p.for_each(|e| {
+                    if let Ok(_out) = e.args() {
+                        // if let Ok(ref mut lock) = last_notification.try_lock() {
+                        //     notify!(do_led_notif, lock, &out.data);
+                        // }
+                        anime_notified.store(true, Ordering::SeqCst);
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
+
+    spawn(move || loop {
+        smol::block_on(executor.tick());
+    });
+    Ok(())
+}
+
+fn do_thermal_notif(profile: &Profile) -> Result<NotificationHandle, Box<dyn Error>> {
+    let icon = match profile {
+        Profile::Balanced => "asus_notif_yellow",
+        Profile::Performance => "asus_notif_red",
+        Profile::Quiet => "asus_notif_green",
+    };
+    let profile: &str = (*profile).into();
+    let x = Notification::new()
+        .summary("ASUS ROG")
+        .body(&format!(
+            "Thermal profile changed to {}",
+            profile.to_uppercase(),
+        ))
+        .hint(Hint::Resident(true))
+        .timeout(2000)
+        .hint(Hint::Category("device".into()))
+        //.hint(Hint::Transient(true))
+        .icon(icon)
+        .show()?;
+    Ok(x)
+}
+
+fn do_led_notif(ledmode: &AuraEffect) -> Result<NotificationHandle, notify_rust::error::Error> {
+    base_notification!(&format!(
+        "Keyboard LED mode changed to {}",
+        ledmode.mode_name()
+    ))
+}
+
+fn do_charge_notif(limit: &u8) -> Result<NotificationHandle, notify_rust::error::Error> {
+    base_notification!(&format!("Battery charge limit changed to {}", limit))
+}
+
+fn do_post_sound_notif(on: &bool) -> Result<NotificationHandle, notify_rust::error::Error> {
+    base_notification!(&format!("BIOS Post sound {}", on))
+}
--- a/rog-control-center/src/page_states.rs
+++ b/rog-control-center/src/page_states.rs
@@ -0,0 +1,294 @@
+use std::{
+    collections::{BTreeMap, HashMap, HashSet},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+};
+
+use egui::Vec2;
+use rog_aura::{usb::AuraPowerDev, AuraEffect, AuraModeNum};
+use rog_dbus::RogDbusClientBlocking;
+use rog_profiles::{fan_curve_set::FanCurveSet, FanCurvePU, Profile};
+use rog_supported::SupportedFunctions;
+
+#[derive(Clone, Debug)]
+pub struct BiosState {
+    /// To be shared to a thread that checks notifications.
+    /// It's a bit general in that it won't provide *what* was
+    /// updated, so the full state needs refresh
+    pub was_notified: Arc<AtomicBool>,
+    pub post_sound: bool,
+    pub dedicated_gfx: bool,
+    pub panel_overdrive: bool,
+    pub dgpu_disable: bool,
+    pub egpu_enable: bool,
+}
+
+impl BiosState {
+    pub fn new(
+        was_notified: Arc<AtomicBool>,
+        supported: &SupportedFunctions,
+        dbus: &RogDbusClientBlocking,
+    ) -> Self {
+        Self {
+            was_notified,
+            post_sound: if supported.rog_bios_ctrl.post_sound {
+                dbus.proxies().rog_bios().post_boot_sound().unwrap() != 0
+            } else {
+                false
+            },
+            dedicated_gfx: if supported.rog_bios_ctrl.dedicated_gfx {
+                dbus.proxies().rog_bios().dedicated_graphic_mode().unwrap() != 0
+            } else {
+                false
+            },
+            panel_overdrive: if supported.rog_bios_ctrl.panel_overdrive {
+                dbus.proxies().rog_bios().panel_overdrive().unwrap() != 0
+            } else {
+                false
+            },
+            // TODO: needs supergfx
+            dgpu_disable: supported.rog_bios_ctrl.dgpu_disable,
+            egpu_enable: supported.rog_bios_ctrl.egpu_enable,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ProfilesState {
+    pub was_notified: Arc<AtomicBool>,
+    pub list: Vec<Profile>,
+    pub current: Profile,
+}
+
+impl ProfilesState {
+    pub fn new(
+        was_notified: Arc<AtomicBool>,
+        supported: &SupportedFunctions,
+        dbus: &RogDbusClientBlocking,
+    ) -> Self {
+        Self {
+            was_notified,
+            list: if supported.platform_profile.platform_profile {
+                dbus.proxies().profile().profiles().unwrap()
+            } else {
+                vec![]
+            },
+            current: if supported.platform_profile.platform_profile {
+                dbus.proxies().profile().active_profile().unwrap()
+            } else {
+                Profile::Balanced
+            },
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct FanCurvesState {
+    pub was_notified: Arc<AtomicBool>,
+    pub show_curve: Profile,
+    pub show_graph: FanCurvePU,
+    pub enabled: HashSet<Profile>,
+    pub curves: HashMap<Profile, FanCurveSet>,
+    pub drag_delta: Vec2,
+}
+
+impl FanCurvesState {
+    pub fn new(
+        was_notified: Arc<AtomicBool>,
+        supported: &SupportedFunctions,
+        dbus: &RogDbusClientBlocking,
+    ) -> Self {
+        let profiles = if supported.platform_profile.platform_profile {
+            dbus.proxies().profile().profiles().unwrap()
+        } else {
+            vec![Profile::Balanced, Profile::Quiet, Profile::Performance]
+        };
+        let enabled = if supported.platform_profile.fan_curves {
+            HashSet::from_iter(
+                dbus.proxies()
+                    .profile()
+                    .enabled_fan_profiles()
+                    .unwrap()
+                    .iter()
+                    .cloned(),
+            )
+        } else {
+            HashSet::from([Profile::Balanced, Profile::Quiet, Profile::Performance])
+        };
+
+        let mut curves: HashMap<Profile, FanCurveSet> = HashMap::new();
+        profiles.iter().for_each(|p| {
+            if supported.platform_profile.fan_curves {
+                let curve = dbus.proxies().profile().fan_curve_data(*p).unwrap();
+                curves.insert(*p, curve);
+            } else {
+                let mut curve = FanCurveSet::default();
+                curve.cpu.pwm = [30, 40, 60, 100, 140, 180, 200, 250];
+                curve.cpu.temp = [20, 30, 40, 50, 70, 80, 90, 100];
+                curve.gpu.pwm = [40, 80, 100, 140, 170, 200, 230, 250];
+                curve.gpu.temp = [20, 30, 40, 50, 70, 80, 90, 100];
+                curves.insert(*p, curve);
+            }
+        });
+
+        let show_curve = if supported.platform_profile.fan_curves {
+            dbus.proxies().profile().active_profile().unwrap()
+        } else {
+            Profile::Balanced
+        };
+
+        Self {
+            was_notified,
+            show_curve,
+            show_graph: FanCurvePU::CPU,
+            enabled,
+            curves,
+            drag_delta: Vec2::default(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct AuraState {
+    pub was_notified: Arc<AtomicBool>,
+    pub current_mode: AuraModeNum,
+    pub modes: BTreeMap<AuraModeNum, AuraEffect>,
+    pub enabled: AuraPowerDev,
+}
+
+impl AuraState {
+    pub fn new(
+        was_notified: Arc<AtomicBool>,
+        supported: &SupportedFunctions,
+        dbus: &RogDbusClientBlocking,
+    ) -> Self {
+        Self {
+            was_notified,
+            current_mode: if !supported.keyboard_led.stock_led_modes.is_empty() {
+                dbus.proxies().led().led_mode().unwrap()
+            } else {
+                AuraModeNum::Static
+            },
+
+            modes: if !supported.keyboard_led.stock_led_modes.is_empty() {
+                dbus.proxies().led().led_modes().unwrap()
+            } else {
+                BTreeMap::new()
+            },
+            enabled: dbus.proxies().led().leds_enabled().unwrap(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct AnimeState {
+    pub was_notified: Arc<AtomicBool>,
+    pub bright: u8,
+    pub boot: bool,
+    pub awake: bool,
+    pub sleep: bool,
+}
+
+impl AnimeState {
+    pub fn new(
+        was_notified: Arc<AtomicBool>,
+        supported: &SupportedFunctions,
+        dbus: &RogDbusClientBlocking,
+    ) -> Self {
+        Self {
+            was_notified,
+            boot: if supported.anime_ctrl.0 {
+                dbus.proxies().anime().boot_enabled().unwrap()
+            } else {
+                false
+            },
+            awake: if supported.anime_ctrl.0 {
+                dbus.proxies().anime().awake_enabled().unwrap()
+            } else {
+                false
+            },
+            // TODO:
+            sleep: false,
+            bright: 200,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PageDataStates {
+    pub was_notified: Arc<AtomicBool>,
+    /// Because much of the app state here is the same as `RogBiosSupportedFunctions`
+    /// we can re-use that structure.
+    pub bios: BiosState,
+    pub aura: AuraState,
+    pub anime: AnimeState,
+    pub profiles: ProfilesState,
+    pub fan_curves: FanCurvesState,
+    pub charge_limit: i16,
+    pub error: Option<String>,
+}
+
+impl PageDataStates {
+    pub fn new(
+        charge_notified: Arc<AtomicBool>,
+        bios_notified: Arc<AtomicBool>,
+        aura_notified: Arc<AtomicBool>,
+        anime_notified: Arc<AtomicBool>,
+        profiles_notified: Arc<AtomicBool>,
+        fans_notified: Arc<AtomicBool>,
+        supported: &SupportedFunctions,
+        dbus: &RogDbusClientBlocking,
+    ) -> Self {
+        Self {
+            was_notified: charge_notified,
+            charge_limit: dbus.proxies().charge().limit().unwrap(),
+            bios: BiosState::new(bios_notified, supported, dbus),
+            aura: AuraState::new(aura_notified, supported, dbus),
+            anime: AnimeState::new(anime_notified, supported, dbus),
+            profiles: ProfilesState::new(profiles_notified, supported, dbus),
+            fan_curves: FanCurvesState::new(fans_notified, supported, dbus),
+            error: None,
+        }
+    }
+
+    pub fn refresh_if_notfied(
+        &mut self,
+        supported: &SupportedFunctions,
+        dbus: &RogDbusClientBlocking,
+    ) -> bool {
+        let mut notified = false;
+        if self.was_notified.load(Ordering::SeqCst) {
+            self.charge_limit = dbus.proxies().charge().limit().unwrap();
+            self.was_notified.store(false, Ordering::SeqCst);
+            notified = true;
+        }
+
+        if self.aura.was_notified.load(Ordering::SeqCst) {
+            self.aura = AuraState::new(self.aura.was_notified.clone(), supported, dbus);
+            self.aura.was_notified.store(false, Ordering::SeqCst);
+            notified = true;
+        }
+
+        if self.bios.was_notified.load(Ordering::SeqCst) {
+            self.bios = BiosState::new(self.bios.was_notified.clone(), supported, dbus);
+            self.bios.was_notified.store(false, Ordering::SeqCst);
+            notified = true;
+        }
+
+        if self.profiles.was_notified.load(Ordering::SeqCst) {
+            self.profiles = ProfilesState::new(self.profiles.was_notified.clone(), supported, dbus);
+            self.profiles.was_notified.store(false, Ordering::SeqCst);
+            notified = true;
+        }
+
+        if self.fan_curves.was_notified.load(Ordering::SeqCst) {
+            self.fan_curves =
+                FanCurvesState::new(self.fan_curves.was_notified.clone(), supported, dbus);
+            self.fan_curves.was_notified.store(false, Ordering::SeqCst);
+            notified = true;
+        }
+        notified
+    }
+}
--- a/rog-control-center/src/widgets/anime_page.rs
+++ b/rog-control-center/src/widgets/anime_page.rs
@@ -0,0 +1,77 @@
+use egui::RichText;
+
+use crate::RogApp;
+
+impl<'a> RogApp<'a> {
+    pub fn anime_page(&mut self, ctx: &egui::Context) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("AniMe Matrix Settings");
+            ui.label("Options are incomplete. Awake + Boot should work");
+
+            let Self {
+                states,
+                asus_dbus: dbus,
+                ..
+            } = self;
+
+            let mut changed = false;
+
+            ui.horizontal_wrapped(|ui| {
+                ui.vertical(|ui| {
+                    let h = 16.0;
+                    ui.set_row_height(22.0);
+                    ui.horizontal_wrapped(|ui| {
+                        ui.label(RichText::new("Brightness").size(h));
+                    });
+                    ui.horizontal_wrapped(|ui| {
+                        ui.label(RichText::new("Boot").size(h));
+                    });
+                    ui.horizontal_wrapped(|ui| {
+                        ui.label(RichText::new("Awake").size(h));
+                    });
+                    ui.horizontal_wrapped(|ui| {
+                        ui.label(RichText::new("Sleep").size(h));
+                    });
+                });
+                ui.vertical(|ui| {
+                    ui.set_row_height(22.0);
+                    ui.horizontal_wrapped(|ui| {
+                        if ui
+                            .add(egui::Slider::new(&mut states.anime.bright, 0..=254))
+                            .changed()
+                        {
+                            changed = true;
+                        }
+                    });
+                    ui.horizontal_wrapped(|ui| {
+                        if ui.checkbox(&mut states.anime.boot, "Enable").changed() {
+                            dbus.proxies()
+                                .anime()
+                                .set_boot_on_off(states.anime.boot)
+                                .map_err(|err| {
+                                    states.error = Some(err.to_string());
+                                })
+                                .ok();
+                        }
+                    });
+                    ui.horizontal_wrapped(|ui| {
+                        if ui.checkbox(&mut states.anime.awake, "Enable").changed() {
+                            dbus.proxies()
+                                .anime()
+                                .set_on_off(states.anime.awake)
+                                .map_err(|err| {
+                                    states.error = Some(err.to_string());
+                                })
+                                .ok();
+                        }
+                    });
+                    ui.horizontal_wrapped(|ui| {
+                        if ui.checkbox(&mut states.anime.sleep, "Enable").changed() {
+                            changed = true;
+                        }
+                    });
+                });
+            });
+        });
+    }
+}
--- a/rog-control-center/src/widgets/aura_page.rs
+++ b/rog-control-center/src/widgets/aura_page.rs
@@ -0,0 +1,455 @@
+use egui::{RichText, Ui};
+use rog_aura::{
+    usb::{AuraDev1866, AuraDev19b6, AuraDevice, AuraPowerDev},
+    AuraModeNum, AuraZone, Colour, Speed,
+};
+use rog_dbus::RogDbusClientBlocking;
+use rog_supported::SupportedFunctions;
+
+use crate::{
+    page_states::{AuraState, PageDataStates},
+    RogApp,
+};
+
+impl<'a> RogApp<'a> {
+    pub fn aura_page(&mut self, ctx: &egui::Context) {
+        let Self {
+            supported,
+            states,
+            asus_dbus: dbus,
+            ..
+        } = self;
+
+        egui::CentralPanel::default().show(ctx, |ui| {
+            Self::aura_power(supported, states, dbus, ui);
+            ui.separator();
+            Self::aura_modes(supported, states, dbus, ui);
+        });
+    }
+
+    fn aura_power(
+        supported: &SupportedFunctions,
+        states: &mut PageDataStates,
+        dbus: &mut RogDbusClientBlocking,
+        ui: &mut Ui,
+    ) {
+        match supported.keyboard_led.prod_id {
+            AuraDevice::X1854 | AuraDevice::X1869 | AuraDevice::X1866 => {
+                Self::aura_power1(supported, states, dbus, ui)
+            }
+            AuraDevice::X19B6 => Self::aura_power2(supported, states, dbus, ui),
+            AuraDevice::Unknown => {}
+        }
+    }
+
+    fn aura_power1(
+        supported: &SupportedFunctions,
+        states: &mut PageDataStates,
+        dbus: &mut RogDbusClientBlocking,
+        ui: &mut Ui,
+    ) {
+        let enabled_states = &mut states.aura.enabled;
+
+        ui.heading("Aura go brrrrr! (incomplete)");
+        ui.separator();
+
+        let boot = &mut enabled_states.x1866.contains(&AuraDev1866::Boot);
+        let sleep = &mut enabled_states.x1866.contains(&AuraDev1866::Sleep);
+        let keyboard = &mut enabled_states.x1866.contains(&AuraDev1866::Keyboard);
+        let lightbar = &mut enabled_states.x1866.contains(&AuraDev1866::Lightbar);
+        let mut changed = false;
+
+        ui.horizontal_wrapped(|ui| {
+            ui.vertical(|ui| {
+                let h = 16.0;
+                ui.set_row_height(22.0);
+                ui.horizontal_wrapped(|ui| {
+                    ui.label(RichText::new("Boot").size(h));
+                });
+                ui.horizontal_wrapped(|ui| {
+                    ui.label(RichText::new("Awake").size(h));
+                });
+                ui.horizontal_wrapped(|ui| {
+                    ui.label(RichText::new("Sleep").size(h));
+                });
+            });
+            ui.vertical(|ui| {
+                ui.set_row_height(22.0);
+                ui.horizontal_wrapped(|ui| {
+                    if ui.checkbox(boot, "Enable").changed() {
+                        changed = true;
+                    }
+                });
+                ui.horizontal_wrapped(|ui| {
+                    if ui.toggle_value(keyboard, "Keyboard").changed() {
+                        changed = true;
+                    }
+                    if !supported.keyboard_led.multizone_led_mode.is_empty() {
+                        if ui.toggle_value(lightbar, "Lightbar").changed() {
+                            changed = true;
+                        }
+                    }
+                });
+                ui.horizontal_wrapped(|ui| {
+                    if ui.checkbox(sleep, "Enable").changed() {
+                        changed = true;
+                    }
+                });
+            });
+        });
+
+        if changed {
+            let mut enabled = Vec::new();
+            let mut disabled = Vec::new();
+
+            let mut modify = |b: bool, a: AuraDev1866| {
+                if b {
+                    enabled.push(a);
+                    if !enabled_states.x1866.contains(&a) {
+                        enabled_states.x1866.push(a);
+                    }
+                } else {
+                    disabled.push(a);
+                    // This would be so much better as a hashset
+                    if enabled_states.x1866.contains(&a) {
+                        let mut idx = 0;
+                        for (i, n) in enabled_states.x1866.iter().enumerate() {
+                            if *n == a {
+                                idx = i;
+                                break;
+                            }
+                        }
+                        enabled_states.x1866.remove(idx);
+                    }
+                }
+            };
+            modify(*boot, AuraDev1866::Boot);
+            modify(*sleep, AuraDev1866::Sleep);
+            modify(*keyboard, AuraDev1866::Keyboard);
+            if !supported.keyboard_led.multizone_led_mode.is_empty() {
+                modify(*lightbar, AuraDev1866::Lightbar);
+            }
+
+            let mut send = |enable: bool, data: Vec<AuraDev1866>| {
+                let options = AuraPowerDev {
+                    x1866: data,
+                    x19b6: vec![],
+                };
+                // build data to send
+                dbus.proxies()
+                    .led()
+                    .set_leds_power(options, enable)
+                    .map_err(|err| {
+                        states.error = Some(err.to_string());
+                    })
+                    .ok();
+            };
+            send(true, enabled);
+            send(false, disabled);
+        }
+    }
+
+    fn aura_power2(
+        supported: &SupportedFunctions,
+        states: &mut PageDataStates,
+        dbus: &mut RogDbusClientBlocking,
+        ui: &mut Ui,
+    ) {
+        let enabled_states = &mut states.aura.enabled;
+
+        ui.heading("Lights go brrrrr! (incomplete)");
+        ui.separator();
+
+        let has_logo = supported
+            .keyboard_led
+            .multizone_led_mode
+            .contains(&AuraZone::Logo);
+        let has_lightbar = supported
+            .keyboard_led
+            .multizone_led_mode
+            .contains(&AuraZone::BarLeft)
+            || supported
+                .keyboard_led
+                .multizone_led_mode
+                .contains(&AuraZone::BarRight);
+
+        let boot_bar = &mut enabled_states.x19b6.contains(&AuraDev19b6::BootBar);
+        let boot_logo = &mut enabled_states.x19b6.contains(&AuraDev19b6::BootLogo);
+        let boot_keyb = &mut enabled_states.x19b6.contains(&AuraDev19b6::BootKeyb);
+
+        let awake_bar = &mut enabled_states.x19b6.contains(&AuraDev19b6::AwakeBar);
+        let awake_logo = &mut enabled_states.x19b6.contains(&AuraDev19b6::AwakeLogo);
+        let awake_keyb = &mut enabled_states.x19b6.contains(&AuraDev19b6::AwakeKeyb);
+
+        let sleep_bar = &mut enabled_states.x19b6.contains(&AuraDev19b6::SleepBar);
+        let sleep_logo = &mut enabled_states.x19b6.contains(&AuraDev19b6::SleepLogo);
+        let sleep_keyb = &mut enabled_states.x19b6.contains(&AuraDev19b6::SleepKeyb);
+
+        let mut changed = false;
+
+        let mut item = |keyboard: &mut bool, logo: &mut bool, lightbar: &mut bool, ui: &mut Ui| {
+            ui.horizontal_wrapped(|ui| {
+                if ui.checkbox(keyboard, "Keyboard").changed() {
+                    changed = true;
+                }
+                if has_logo && ui.checkbox(logo, "Logo").changed() {
+                    changed = true;
+                }
+                if has_lightbar && ui.checkbox(lightbar, "Lightbar").changed() {
+                    changed = true;
+                }
+            });
+        };
+
+        ui.horizontal_wrapped(|ui| {
+            ui.vertical(|ui| {
+                let h = 16.0;
+                ui.set_row_height(22.0);
+                ui.horizontal_wrapped(|ui| {
+                    ui.label(RichText::new("Boot").size(h));
+                });
+                ui.horizontal_wrapped(|ui| {
+                    ui.label(RichText::new("Awake").size(h));
+                });
+                ui.horizontal_wrapped(|ui| {
+                    ui.label(RichText::new("Sleep").size(h));
+                });
+            });
+            ui.vertical(|ui| {
+                ui.set_row_height(22.0);
+                item(boot_keyb, boot_logo, boot_bar, ui);
+                item(awake_keyb, awake_logo, awake_bar, ui);
+                item(sleep_keyb, sleep_logo, sleep_bar, ui);
+            });
+        });
+
+        if changed {
+            let mut enabled = Vec::new();
+            let mut disabled = Vec::new();
+
+            let mut modify = |b: bool, a: AuraDev19b6| {
+                if b {
+                    enabled.push(a);
+                    if !enabled_states.x19b6.contains(&a) {
+                        enabled_states.x19b6.push(a);
+                    }
+                } else {
+                    disabled.push(a);
+                    // This would be so much better as a hashset
+                    if enabled_states.x19b6.contains(&a) {
+                        let mut idx = 0;
+                        for (i, n) in enabled_states.x19b6.iter().enumerate() {
+                            if *n == a {
+                                idx = i;
+                                break;
+                            }
+                        }
+                        enabled_states.x1866.remove(idx);
+                    }
+                }
+            };
+            modify(*boot_keyb, AuraDev19b6::BootKeyb);
+            modify(*sleep_keyb, AuraDev19b6::SleepKeyb);
+            modify(*awake_keyb, AuraDev19b6::AwakeKeyb);
+            if supported
+                .keyboard_led
+                .multizone_led_mode
+                .contains(&AuraZone::Logo)
+            {
+                modify(*boot_logo, AuraDev19b6::BootLogo);
+                modify(*sleep_logo, AuraDev19b6::SleepLogo);
+                modify(*awake_logo, AuraDev19b6::AwakeLogo);
+            }
+            if supported
+                .keyboard_led
+                .multizone_led_mode
+                .contains(&AuraZone::BarLeft)
+            {
+                modify(*boot_bar, AuraDev19b6::BootBar);
+                modify(*sleep_bar, AuraDev19b6::SleepBar);
+                modify(*awake_bar, AuraDev19b6::AwakeBar);
+            }
+
+            let mut send = |enable: bool, data: Vec<AuraDev19b6>| {
+                let options = AuraPowerDev {
+                    x1866: vec![],
+                    x19b6: data,
+                };
+                // build data to send
+                dbus.proxies()
+                    .led()
+                    .set_leds_power(options, enable)
+                    .map_err(|err| {
+                        states.error = Some(err.to_string());
+                    })
+                    .ok();
+            };
+            send(true, enabled);
+            send(false, disabled);
+        }
+    }
+
+    fn aura_modes(
+        supported: &SupportedFunctions,
+        states: &mut PageDataStates,
+        dbus: &mut RogDbusClientBlocking,
+        ui: &mut Ui,
+    ) {
+        let mut changed = false;
+        let mut selected = states.aura.current_mode;
+
+        let has_keyzones = supported
+            .keyboard_led
+            .multizone_led_mode
+            .contains(&AuraZone::Key2);
+        let has_logo = supported
+            .keyboard_led
+            .multizone_led_mode
+            .contains(&AuraZone::Logo);
+        let has_lightbar = supported
+            .keyboard_led
+            .multizone_led_mode
+            .contains(&AuraZone::BarLeft)
+            || supported
+                .keyboard_led
+                .multizone_led_mode
+                .contains(&AuraZone::BarRight);
+
+        ui.heading("Aura modes");
+        let mut item = |a: AuraModeNum, ui: &mut Ui| {
+            if ui
+                .selectable_value(&mut selected, a, format!("{:?}", a))
+                .clicked()
+            {
+                changed = true;
+            }
+        };
+
+        ui.horizontal_wrapped(|ui| {
+            for a in states.aura.modes.keys() {
+                item(*a, ui);
+            }
+        });
+
+        // TODO: Need some sort of mapping to enable options only if
+        //  they actually work.
+        if let Some(effect) = states.aura.modes.get_mut(&selected) {
+            let mut zone_button = |a: AuraZone, ui: &mut Ui| {
+                ui.selectable_value(&mut effect.zone, a, format!("{:?}", a));
+            };
+            let mut speed_button = |a: Speed, ui: &mut Ui| {
+                ui.selectable_value(&mut effect.speed, a, format!("{:?}", a));
+            };
+            let mut dir_button = |a: rog_aura::Direction, ui: &mut Ui| {
+                ui.selectable_value(&mut effect.direction, a, format!("{:?}", a));
+            };
+
+            let mut c1: [f32; 3] = effect.colour1.into();
+            let mut c2: [f32; 3] = effect.colour2.into();
+
+            ui.separator();
+            ui.horizontal_wrapped(|ui| {
+                ui.vertical(|ui| {
+                    let h = 16.0;
+                    ui.set_row_height(22.0);
+                    if has_keyzones || has_lightbar || has_logo {
+                        ui.horizontal_wrapped(|ui| {
+                            ui.label(RichText::new("Zone").size(h));
+                        });
+                    }
+                    ui.horizontal_wrapped(|ui| {
+                        ui.label(RichText::new("Colour 1").size(h));
+                    });
+                    ui.horizontal_wrapped(|ui| {
+                        ui.label(RichText::new("Colour 2").size(h));
+                    });
+                    ui.horizontal_wrapped(|ui| {
+                        ui.label(RichText::new("Speed").size(h));
+                    });
+                    ui.horizontal_wrapped(|ui| {
+                        ui.label(RichText::new("Direction").size(h));
+                    });
+                });
+                ui.vertical(|ui| {
+                    ui.set_row_height(22.0);
+                    if has_keyzones || has_lightbar || has_logo {
+                        ui.horizontal_wrapped(|ui| {
+                            zone_button(AuraZone::None, ui);
+                            if has_keyzones {
+                                zone_button(AuraZone::Key1, ui);
+                                zone_button(AuraZone::Key2, ui);
+                                zone_button(AuraZone::Key3, ui);
+                                zone_button(AuraZone::Key4, ui);
+                            }
+                            if has_logo {
+                                zone_button(AuraZone::Logo, ui);
+                            }
+                            if has_lightbar {
+                                zone_button(AuraZone::BarLeft, ui);
+                                zone_button(AuraZone::BarRight, ui);
+                            }
+                        });
+                    }
+
+                    egui::color_picker::color_edit_button_rgb(ui, &mut c1);
+                    egui::color_picker::color_edit_button_rgb(ui, &mut c2);
+
+                    ui.horizontal_wrapped(|ui| {
+                        speed_button(Speed::Low, ui);
+                        speed_button(Speed::Med, ui);
+                        speed_button(Speed::High, ui);
+                    });
+
+                    ui.horizontal_wrapped(|ui| {
+                        dir_button(rog_aura::Direction::Left, ui);
+                        dir_button(rog_aura::Direction::Down, ui);
+                        dir_button(rog_aura::Direction::Right, ui);
+                        dir_button(rog_aura::Direction::Up, ui);
+                    });
+                });
+            });
+
+            effect.colour1 = Colour::from(&c1);
+            effect.colour2 = Colour::from(&c2);
+        }
+
+        ui.separator();
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
+            if ui.add(egui::Button::new("Cancel")).clicked() {
+                let notif = states.aura.was_notified.clone();
+                states.aura.modes = AuraState::new(notif, supported, dbus).modes;
+            }
+
+            if ui.add(egui::Button::new("Apply")).clicked() {
+                changed = true;
+            }
+        });
+
+        // egui::TopBottomPanel::bottom("error_bar")
+        //     .default_height(26.0)
+        //     .show(ctx, |ui| {
+        //         ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
+        //             if ui.add(egui::Button::new("Cancel")).clicked() {
+        //                 let notif = states.aura.was_notified.clone();
+        //                 states.aura.modes = AuraState::new(notif, supported, dbus).modes;
+        //             }
+
+        //             if ui.add(egui::Button::new("Apply")).clicked() {
+        //                 changed = true;
+        //             }
+        //         });
+        //     });
+
+        if changed {
+            states.aura.current_mode = selected;
+
+            dbus.proxies()
+                .led()
+                .set_led_mode(states.aura.modes.get(&selected).unwrap())
+                .map_err(|err| {
+                    states.error = Some(err.to_string());
+                })
+                .ok();
+        }
+    }
+}
--- a/rog-control-center/src/widgets/fan_curve_page.rs
+++ b/rog-control-center/src/widgets/fan_curve_page.rs
@@ -0,0 +1,199 @@
+use crate::{
+    page_states::{FanCurvesState, ProfilesState},
+    RogApp,
+};
+use egui::{plot::Points, Ui};
+use rog_dbus::RogDbusClientBlocking;
+use rog_profiles::{FanCurvePU, Profile};
+use rog_supported::SupportedFunctions;
+
+impl<'a> RogApp<'a> {
+    pub fn fan_curve_page(&mut self, ctx: &egui::Context) {
+        let Self {
+            supported,
+            states,
+            asus_dbus: dbus,
+            ..
+        } = self;
+
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("Custom fan curves");
+            ui.label("A fan curve is only active when the related profile is active and the curve is enabled");
+            Self::fan_curve(
+                supported,
+                &mut states.profiles,
+                &mut states.fan_curves,
+                dbus, &mut states.error,
+                ui,
+            );
+
+            Self::fan_graphs(&mut states.profiles, &mut states.fan_curves, dbus, &mut states.error, ui);
+        });
+    }
+
+    fn fan_curve(
+        supported: &SupportedFunctions,
+        profiles: &mut ProfilesState,
+        curves: &mut FanCurvesState,
+        dbus: &RogDbusClientBlocking,
+        do_error: &mut Option<String>,
+        ui: &mut Ui,
+    ) {
+        ui.separator();
+        ui.label("Enabled fan-curves");
+
+        let mut changed = false;
+        ui.horizontal(|ui| {
+            let mut item = |p: Profile, _curves: &mut FanCurvesState, mut checked: bool| {
+                if ui
+                    .add(egui::Checkbox::new(&mut checked, format!("{:?}", p)))
+                    .changed()
+                {
+                    dbus.proxies()
+                        .profile()
+                        .set_fan_curve_enabled(p, checked)
+                        .map_err(|err| {
+                            *do_error = Some(err.to_string());
+                        })
+                        .ok();
+
+                    #[cfg(feature = "mocking")]
+                    if !checked {
+                        _curves.enabled.remove(&p);
+                    } else {
+                        _curves.enabled.insert(p);
+                    }
+                    changed = true;
+                }
+            };
+
+            for f in profiles.list.iter() {
+                item(*f, curves, curves.enabled.contains(f));
+            }
+        });
+
+        if changed {
+            // Need to update app data if change made
+            #[cfg(not(feature = "mocking"))]
+            {
+                let notif = curves.was_notified.clone();
+                *curves = FanCurvesState::new(notif, supported, dbus);
+            }
+        }
+    }
+
+    fn fan_graphs(
+        profiles: &mut ProfilesState,
+        curves: &mut FanCurvesState,
+        dbus: &RogDbusClientBlocking,
+        do_error: &mut Option<String>,
+        ui: &mut Ui,
+    ) {
+        ui.separator();
+
+        let mut item = |p: Profile, ui: &mut Ui| {
+            ui.selectable_value(&mut curves.show_curve, p, format!("{p:?}"));
+        };
+
+        ui.horizontal_wrapped(|ui| {
+            for a in curves.curves.iter() {
+                item(*a.0, ui);
+            }
+
+            ui.selectable_value(
+                &mut curves.show_graph,
+                FanCurvePU::CPU,
+                format!("{:?}", FanCurvePU::CPU),
+            );
+            ui.selectable_value(
+                &mut curves.show_graph,
+                FanCurvePU::GPU,
+                format!("{:?}", FanCurvePU::GPU),
+            );
+        });
+
+        let curve = curves.curves.get_mut(&curves.show_curve).unwrap();
+
+        use egui::plot::{Line, Plot, PlotPoints};
+
+        let data = if curves.show_graph == FanCurvePU::CPU {
+            &mut curve.cpu
+        } else {
+            &mut curve.gpu
+        };
+
+        let points = data.temp.iter().enumerate().map(|(idx, x)| {
+            let x = *x as f64;
+            let y = ((data.pwm[idx] as u32) * 100 / 255) as f64;
+            [x, y]
+        });
+
+        let line = Line::new(PlotPoints::from_iter(points.clone())).width(2.0);
+        let points = Points::new(PlotPoints::from_iter(points)).radius(3.0);
+
+        Plot::new("my_plot")
+            .view_aspect(2.0)
+            // .center_x_axis(true)
+            // .center_y_axis(true)
+            .include_x(0.0)
+            .include_x(110.0)
+            .include_y(0.0)
+            .include_y(110.0)
+            .allow_scroll(false)
+            .allow_drag(false)
+            .allow_boxed_zoom(false)
+            .x_axis_formatter(|d, _r| format!("{}", d))
+            .y_axis_formatter(|d, _r| format!("{:.*}%", 1, d))
+            .label_formatter(|name, value| {
+                if !name.is_empty() {
+                    format!("{}: {:.*}%", name, 1, value.y)
+                } else {
+                    format!("Temp {}c\nFan {:.*}%", value.x as u8, 1, value.y)
+                }
+            })
+            .show(ui, |plot_ui| {
+                if plot_ui.plot_hovered() {
+                    let mut idx = 0;
+
+                    if let Some(point) = plot_ui.pointer_coordinate() {
+                        let mut x: i32 = 255;
+                        for (i, n) in data.temp.iter().enumerate() {
+                            let tmp = x.min((point.x as i32 - *n as i32).abs());
+                            if tmp < x {
+                                x = tmp;
+                                idx = i;
+                            }
+                        }
+
+                        if plot_ui.plot_clicked() {
+                            data.temp[idx] = point.x as u8;
+                            data.pwm[idx] = (point.y * 255.0 / 100.0) as u8;
+                        } else {
+                            let drag = plot_ui.pointer_coordinate_drag_delta();
+                            if drag.length_sq() != 0.0 {
+                                data.temp[idx] = (point.x as f32 + drag.x) as u8;
+                                data.pwm[idx] = ((point.y as f32 + drag.y) * 255.0 / 100.0) as u8;
+                            }
+                        }
+                    }
+                }
+                plot_ui.line(line);
+                plot_ui.points(points)
+            });
+
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
+            if ui.add(egui::Button::new("Apply Fan-curve")).clicked() {
+                #[cfg(not(feature = "mocking"))]
+                dbus.proxies()
+                    .profile()
+                    .set_fan_curve(profiles.current, data.clone())
+                    .map_err(|err| {
+                        *do_error = Some(err.to_string());
+                    })
+                    .ok();
+                #[cfg(feature = "mocking")]
+                dbg!("Applied");
+            }
+        });
+    }
+}
--- a/rog-control-center/src/widgets/mod.rs
+++ b/rog-control-center/src/widgets/mod.rs
@@ -0,0 +1,13 @@
+mod anime_page;
+mod aura_page;
+mod fan_curve_page;
+mod side_panel;
+mod system_page;
+mod top_bar;
+
+pub use anime_page::*;
+pub use aura_page::*;
+pub use fan_curve_page::*;
+pub use side_panel::*;
+pub use system_page::*;
+pub use top_bar::*;
--- a/rog-control-center/src/widgets/side_panel.rs
+++ b/rog-control-center/src/widgets/side_panel.rs
@@ -0,0 +1,62 @@
+use crate::{Page, RogApp};
+
+impl<'a> RogApp<'a> {
+    pub fn side_panel(&mut self, ctx: &egui::Context) {
+        egui::SidePanel::left("side_panel")
+            .resizable(false)
+            .default_width(60.0) // TODO: set size to match icon buttons when done
+            .show(ctx, |ui| {
+                let Self { page, .. } = self;
+
+                ui.heading("Functions");
+
+                ui.separator();
+                if ui
+                    .selectable_value(page, Page::System, "System Settings")
+                    .clicked()
+                {
+                    *page = Page::System;
+                }
+
+                if self.supported.platform_profile.fan_curves || cfg!(feature = "mocking") {
+                    ui.separator();
+                    if ui
+                        .selectable_value(page, Page::FanCurves, "Fan Curves")
+                        .clicked()
+                    {
+                        *page = Page::FanCurves;
+                    }
+                }
+
+                if !self.supported.keyboard_led.stock_led_modes.is_empty()
+                    || cfg!(feature = "mocking")
+                {
+                    ui.separator();
+                    if ui
+                        .selectable_value(page, Page::AuraEffects, "Keyboard Aura")
+                        .clicked()
+                    {
+                        *page = Page::AuraEffects;
+                    }
+                }
+
+                if self.supported.anime_ctrl.0 || cfg!(feature = "mocking") {
+                    ui.separator();
+                    if ui
+                        .selectable_value(page, Page::AnimeMatrix, "AniMe Matrix")
+                        .clicked()
+                    {
+                        *page = Page::AnimeMatrix;
+                    }
+                }
+
+                ui.with_layout(egui::Layout::bottom_up(egui::Align::LEFT), |ui| {
+                    ui.horizontal(|ui| {
+                        ui.spacing_mut().item_spacing.x = 0.0;
+                        ui.label("Source code ");
+                        ui.hyperlink_to("rog-gui.", "https://gitlab.com/asus-linux/rog-gui");
+                    });
+                });
+            });
+    }
+}
--- a/rog-control-center/src/widgets/system_page.rs
+++ b/rog-control-center/src/widgets/system_page.rs
@@ -0,0 +1,117 @@
+use crate::{page_states::PageDataStates, RogApp};
+use egui::Ui;
+use rog_dbus::RogDbusClientBlocking;
+use rog_profiles::Profile;
+
+impl<'a> RogApp<'a> {
+    pub fn system_page(&mut self, ctx: &egui::Context) {
+        let Self {
+            supported,
+            states,
+            asus_dbus: dbus,
+            ..
+        } = self;
+
+        egui::CentralPanel::default().show(ctx, |ui| {
+            // The central panel the region left after adding TopPanel's and SidePanel's
+
+            ui.heading("Experimental application for asusd");
+            ui.horizontal(|ui| {
+                egui::global_dark_light_mode_buttons(ui);
+                egui::warn_if_debug_build(ui);
+            });
+
+            ui.separator();
+
+            egui::ScrollArea::vertical().show(ui, |ui| {
+                ui.heading("Charge control");
+                let slider = egui::Slider::new(&mut states.charge_limit, 20..=100)
+                    .text("Limit")
+                    .step_by(1.0);
+                if ui.add(slider).drag_released() {
+                    dbus.proxies()
+                        .charge()
+                        .set_limit(states.charge_limit as u8)
+                        .map_err(|err| {
+                            states.error = Some(err.to_string());
+                        })
+                        .ok();
+                }
+
+                ui.separator();
+                ui.heading("Bios options");
+
+                if supported.rog_bios_ctrl.post_sound {
+                    if ui
+                        .add(egui::Checkbox::new(
+                            &mut states.bios.post_sound,
+                            "POST sound",
+                        ))
+                        .changed()
+                    {
+                        dbus.proxies()
+                            .rog_bios()
+                            .set_post_boot_sound(states.bios.post_sound)
+                            .map_err(|err| {
+                                states.error = Some(err.to_string());
+                            })
+                            .ok();
+                    }
+                }
+
+                if supported.rog_bios_ctrl.dedicated_gfx {
+                    if ui
+                        .add(egui::Checkbox::new(
+                            &mut states.bios.dedicated_gfx,
+                            "G-Sync Dedicated GPU mode",
+                        ))
+                        .changed()
+                    {
+                        dbus.proxies()
+                            .rog_bios()
+                            .set_dedicated_graphic_mode(states.bios.dedicated_gfx)
+                            .map_err(|err| {
+                                states.error = Some(err.to_string());
+                            })
+                            .ok();
+                    }
+                }
+
+                if supported.platform_profile.platform_profile {
+                    Self::platform_profile(states, dbus, ui);
+                }
+            });
+        });
+    }
+
+    fn platform_profile(states: &mut PageDataStates, dbus: &RogDbusClientBlocking, ui: &mut Ui) {
+        ui.separator();
+        ui.heading("Platform profile");
+
+        let mut changed = false;
+        let mut item = |p: Profile, ui: &mut Ui| {
+            if ui
+                .selectable_value(&mut states.profiles.current, p, format!("{p:?}"))
+                .clicked()
+            {
+                changed = true;
+            }
+        };
+
+        ui.horizontal_wrapped(|ui| {
+            for a in states.profiles.list.iter() {
+                item(*a, ui);
+            }
+        });
+
+        if changed {
+            dbus.proxies()
+                .profile()
+                .set_active_profile(states.profiles.current)
+                .map_err(|err| {
+                    states.error = Some(err.to_string());
+                })
+                .ok();
+        };
+    }
+}
--- a/rog-control-center/src/widgets/top_bar.rs
+++ b/rog-control-center/src/widgets/top_bar.rs
@@ -0,0 +1,53 @@
+use crate::RogApp;
+
+impl<'a> RogApp<'a> {
+    pub fn top_bar(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        let Self { states, config, .. } = self;
+
+        egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
+            // The top panel is often a good place for a menu bar:
+            egui::menu::bar(ui, |ui| {
+                ui.menu_button("File", |ui| {
+                    if ui.button("Quit").clicked() {
+                        frame.quit();
+                    }
+                });
+                ui.menu_button("Settings", |ui| {
+                    let (mut in_bg, mut hidden) =
+                        { (config.run_in_background, config.startup_in_background) };
+                    if ui.checkbox(&mut in_bg, "Run in Background").clicked() {
+                        config.run_in_background = in_bg;
+                        config
+                            .save()
+                            .map_err(|err| {
+                                states.error = Some(err.to_string());
+                            })
+                            .ok();
+                    }
+                    if ui.checkbox(&mut hidden, "Startup Hidden").clicked() {
+                        config.startup_in_background = in_bg;
+                        config
+                            .save()
+                            .map_err(|err| {
+                                states.error = Some(err.to_string());
+                            })
+                            .ok();
+                    }
+                    if ui
+                        .checkbox(&mut config.enable_notifications, "Enable Notifications")
+                        .clicked()
+                    {
+                        config.enable_notifications = in_bg;
+                        // TODO: set an atomicbool used in the notif thread
+                        config
+                            .save()
+                            .map_err(|err| {
+                                states.error = Some(err.to_string());
+                            })
+                            .ok();
+                    }
+                });
+            });
+        });
+    }
+}
				`@@ -0,0 +1 @@`
				`{"buildTargets":["all","build","clean","distclean","install","uninstall","update","vendor"],"launchTargets":[],"customConfigurationProvider":{"workspaceBrowse":{"browsePath":[],"compilerArgs":[]},"fileIndex":[]}}`