Seed defaults from tokyo-night on omarchy installs

New ThemeState pulls palette and 0- wallpaper from the installed
tokyo-night theme when available, falling back to the existing
Catppuccin palette in standalone mode. Frontend calls GetInitialState
on mount so stores start with the seeded values instead of their
hardcoded defaults.

Author: bjarneo

app.go

@@ -68,6 +68,13 @@ func (a *App) GetThemeColors() map[string]string {
 	return a.themeWatcher.CurrentColors()
 }
 
+// GetInitialState returns the backend-seeded theme state so the
+// frontend can show the right defaults on first paint (e.g. tokyo-night
+// palette + wallpaper on omarchy installs).
+func (a *App) GetInitialState() theme.StateSnapshot {
+	return a.state.Snapshot()
+}
+
 // NewApp creates a new App instance.
 func NewApp() *App {
 	return &App{

frontend/src/App.svelte

@@ -111,6 +111,20 @@
             if (tab) setActiveTab(tab as any);
         } catch {}
 
+        // Seed stores from backend defaults (tokyo-night on omarchy, blank
+        // otherwise). Stores init to DEFAULT_PALETTE at module load, so
+        // this overwrites those before any user interaction.
+        try {
+            const {GetInitialState} = await import('../wailsjs/go/main/App');
+            const s = await GetInitialState();
+            if (s?.palette?.length >= 16) {
+                setPalette(s.palette, true);
+            }
+            if (s?.wallpaperPath) {
+                setWallpaperPath(s.wallpaperPath);
+            }
+        } catch {}
+
         initKeyboardShortcuts();
 
         registerShortcut('ctrl+z', undoAction);

frontend/wailsjs/go/main/App.d.ts

@@ -64,6 +64,8 @@ export function GetFavorites(): Promise<Array<favorites.Favorite>>;
 
 export function GetFocusTab(): Promise<string>;
 
+export function GetInitialState(): Promise<theme.StateSnapshot>;
+
 export function GetMediaURL(arg1: string): Promise<string>;
 
 export function GetPreview(arg1: string): Promise<string>;

frontend/wailsjs/go/main/App.js

@@ -82,6 +82,10 @@ export function GetFocusTab() {
     return window['go']['main']['App']['GetFocusTab']();
 }
 
+export function GetInitialState() {
+    return window['go']['main']['App']['GetInitialState']();
+}
+
 export function GetMediaURL(arg1) {
     return window['go']['main']['App']['GetMediaURL'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -324,6 +324,63 @@ export namespace omarchy {
     }
 }
 
+export namespace template {
+    export class ColorRoles {
+        background: string;
+        foreground: string;
+        black: string;
+        red: string;
+        green: string;
+        yellow: string;
+        blue: string;
+        magenta: string;
+        cyan: string;
+        white: string;
+        bright_black: string;
+        bright_red: string;
+        bright_green: string;
+        bright_yellow: string;
+        bright_blue: string;
+        bright_magenta: string;
+        bright_cyan: string;
+        bright_white: string;
+        accent: string;
+        cursor: string;
+        selection_foreground: string;
+        selection_background: string;
+
+        static createFrom(source: any = {}) {
+            return new ColorRoles(source);
+        }
+
+        constructor(source: any = {}) {
+            if ('string' === typeof source) source = JSON.parse(source);
+            this.background = source['background'];
+            this.foreground = source['foreground'];
+            this.black = source['black'];
+            this.red = source['red'];
+            this.green = source['green'];
+            this.yellow = source['yellow'];
+            this.blue = source['blue'];
+            this.magenta = source['magenta'];
+            this.cyan = source['cyan'];
+            this.white = source['white'];
+            this.bright_black = source['bright_black'];
+            this.bright_red = source['bright_red'];
+            this.bright_green = source['bright_green'];
+            this.bright_yellow = source['bright_yellow'];
+            this.bright_blue = source['bright_blue'];
+            this.bright_magenta = source['bright_magenta'];
+            this.bright_cyan = source['bright_cyan'];
+            this.bright_white = source['bright_white'];
+            this.accent = source['accent'];
+            this.cursor = source['cursor'];
+            this.selection_foreground = source['selection_foreground'];
+            this.selection_background = source['selection_background'];
+        }
+    }
+}
+
 export namespace theme {
     export class ApplyResult {
         success: boolean;
@@ -365,6 +422,57 @@ export namespace theme {
             this.videoCpuMode = source['videoCpuMode'];
         }
     }
+    export class StateSnapshot {
+        palette: string[];
+        wallpaperPath: string;
+        lightMode: boolean;
+        lockedColors: Record<number, boolean>;
+        colorRoles: template.ColorRoles;
+        extendedColors: Record<string, string>;
+        extractionMode: string;
+        additionalImages: string[];
+        appOverrides: Record<string, any>;
+
+        static createFrom(source: any = {}) {
+            return new StateSnapshot(source);
+        }
+
+        constructor(source: any = {}) {
+            if ('string' === typeof source) source = JSON.parse(source);
+            this.palette = source['palette'];
+            this.wallpaperPath = source['wallpaperPath'];
+            this.lightMode = source['lightMode'];
+            this.lockedColors = source['lockedColors'];
+            this.colorRoles = this.convertValues(
+                source['colorRoles'],
+                template.ColorRoles
+            );
+            this.extendedColors = source['extendedColors'];
+            this.extractionMode = source['extractionMode'];
+            this.additionalImages = source['additionalImages'];
+            this.appOverrides = source['appOverrides'];
+        }
+
+        convertValues(a: any, classs: any, asMap: boolean = false): any {
+            if (!a) {
+                return a;
+            }
+            if (a.slice && a.map) {
+                return (a as any[]).map(elem =>
+                    this.convertValues(elem, classs)
+                );
+            } else if ('object' === typeof a) {
+                if (asMap) {
+                    for (const key of Object.keys(a)) {
+                        a[key] = new classs(a[key]);
+                    }
+                    return a;
+                }
+                return new classs(a);
+            }
+            return a;
+        }
+    }
 }
 
 export namespace wallhaven {

internal/omarchy/themes.go

@@ -105,3 +105,42 @@ func LoadAllThemes() ([]Theme, error) {
 
 	return themes, nil
 }
+
+// TokyoNightDefaults loads the tokyo-night palette and its first
+// wallpaper from a local omarchy install, for use as Aether's
+// out-of-the-box defaults. Returns ok=false when the theme isn't
+// present (e.g. standalone installs without omarchy).
+func TokyoNightDefaults() (palette [16]string, bg, fg, wallpaper string, ok bool) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return
+	}
+	candidates := []string{
+		filepath.Join(home, ".config", "omarchy", "themes", "tokyo-night"),
+		filepath.Join(home, ".local", "share", "omarchy", "themes", "tokyo-night"),
+	}
+
+	for _, themeDir := range candidates {
+		data, err := os.ReadFile(filepath.Join(themeDir, "colors.toml"))
+		if err != nil {
+			continue
+		}
+		palette, bg, fg = ParseColorsToml(string(data))
+
+		// os.ReadDir returns entries sorted by filename, so the first
+		// image is tokyo-night's "0-*" wallpaper by convention.
+		if entries, err := os.ReadDir(filepath.Join(themeDir, "backgrounds")); err == nil {
+			for _, e := range entries {
+				ext := strings.ToLower(filepath.Ext(e.Name()))
+				if ext == ".jpg" || ext == ".jpeg" || ext == ".png" || ext == ".webp" {
+					wallpaper = filepath.Join(themeDir, "backgrounds", e.Name())
+					break
+				}
+			}
+		}
+
+		ok = true
+		return
+	}
+	return
+}

internal/theme/state.go

@@ -2,6 +2,7 @@ package theme
 
 import (
 	"aether/internal/color"
+	"aether/internal/omarchy"
 	"aether/internal/template"
 )
 
@@ -41,10 +42,20 @@ var DefaultPalette = [16]string{
 }
 
 // NewThemeState returns a ThemeState initialised with default values.
+// On omarchy systems it seeds the palette and wallpaper from the
+// installed tokyo-night theme; standalone installs keep DefaultPalette.
 func NewThemeState() *ThemeState {
+	palette := DefaultPalette
+	var wallpaper string
+	if p, _, _, w, ok := omarchy.TokyoNightDefaults(); ok {
+		palette = p
+		wallpaper = w
+	}
+
 	s := &ThemeState{
-		Palette:          DefaultPalette,
-		BasePalette:      DefaultPalette,
+		Palette:          palette,
+		BasePalette:      palette,
+		WallpaperPath:    wallpaper,
 		LockedColors:     make(map[int]bool),
 		Adjustments:      color.DefaultAdjustments(),
 		ExtendedColors:   make(map[string]string),