Desk Control Center: The Full Description

Desk Control Center is a small, purpose-built Mac application I designed and built to turn a secondary touchscreen into a dedicated control panel for my desk. Instead of digging through menus, switching apps, or hunting for the right window, I glance down at a strip of touch-friendly widgets and tap to do the things I do constantly through the day: see what’s playing, move a window to the right monitor, jump into a project, check how much of my Claude budget I’ve used, start a timer, take notes during a meeting. Elsewhere in this series I argue about why a tool with an audience of one is worth building at all, and tell the stories of the hardware fighting back. This piece is neither. It is the full description of the thing itself, so you can see exactly what was built and decide for yourself whether it was worth it.

Think of it as the row of controls in a car’s center console, but for my computer. Each control is a self-contained tile. They sit side by side in a single horizontal strip sized exactly to the screen, every button is large enough to hit with a finger, and the whole thing stays out of the way of my main monitors. It is a support surface that quietly handles the small, repetitive actions so my primary screens stay focused on actual work. It is built natively for macOS and runs full-screen on a Corsair touchscreen mounted at my desk, and everything it shows is pulled live from the real apps and services I use, so it is always an accurate reflection of what is actually happening on my machine.

The device it runs on

The app is built for the Corsair Xeneon Edge, a 14.5-inch touchscreen accessory designed to sit on a desk as a secondary display. Four of its properties shaped nearly every decision in the app.

It is long and short. The screen is an unusual ultrawide shape, 2560 by 720 pixels at a 32:9 ratio, more like a letterbox strip than a normal monitor, which is why the app is laid out as a single horizontal row of tiles rather than a grid. It is a touchscreen, supporting up to five points of multi-touch, so every control is sized for fingertips, taps get a visual ripple for confirmation, and you can swipe between tiles. It is a secondary screen rather than the main one: in my setup it sits below two Dell 27-inch monitors that sit above a large Samsung ultrawide, and the app knows about all three displays and can move windows between them. And it connects over a single USB-C cable carrying both the picture and the touch signal, which the app is deliberate about. If the touchscreen gets unplugged it retreats to a small menu-bar window on my main display, and when I plug the device back in it returns to full-screen on its own with no restart.

Because the app talks directly to the touch hardware to get smooth multi-touch and reject accidental palm contact, it runs as a personal, self-signed app rather than something from the App Store. That tradeoff is what makes the deep hardware and window-control integration possible.

How it is organized

The screen is a single left-to-right row of tiles. Some are grouped: a few of the smaller ones stack vertically to share a column, and two pairs each share one slot you flip between by tapping the tile’s header, like turning a page. One of the list tiles, Pinned Apps, stretches to fill any leftover space so the row always reaches edge to edge. From left to right, the default arrangement is Date and Time, Claude Usage, and Window Control stacked together in one column; then Spotify; then Pinned Apps; then Pinned VS Code and Work Sets sharing one swipeable slot; then App Control Center and Timers and Stopwatches sharing another.

Running along the very top of the panel is a thin status strip. On the left is a row of small labeled dots for the app’s key connections: Accessibility, the touchscreen, Spotify, and the Claude usage source. Each dot is green when that connection is healthy and gray when it is not, giving an at-a-glance read on whether everything the app depends on is wired up. These are deliberately kept up here as panel-wide system status rather than cluttering the individual widget cards.

On the right side of that same strip sit the battery levels of my connected Bluetooth devices, each shown as a small device icon with its charge percentage, so a glance tells me what is running low; the percentage tints amber and then red as a device drains. Covering everything took two sources working together. Apple’s own keyboard, mouse, and trackpad report their charge through the Mac’s device layer, while other standards-based Bluetooth devices, like my gaming mouse, are read directly over Bluetooth. The strip merges both and skips anything that does not report a level, which means a few gaming peripherals using their own proprietary scheme over a USB dongle stay silent.

Date and Time

Why I built this one: the Mac’s own clock sits in the far upper-right corner of the G9, at the top of a very wide screen and well outside my line of sight. Down on the panel the time is closer to where I am already looking.

A clean, always-correct clock. It shows the full date and the current time in whatever 12- or 24-hour format my Mac is set to. Seconds are hidden by default to keep it calm. There is deliberately no title or chrome; the date and time speak for themselves, and dropping the title band gives the numbers more room. The clock’s update is aligned to the exact minute boundary rather than ticking on some random offset, so the minute flips over precisely when it should.

Sharing the card on the right is a compact weather summary, lined up so it sits alongside the clock without crowding it: the current condition as a small icon with separate day and night versions, the temperature on the top line, then today’s high and low beneath. The icon carries a gentle, ambient animation matched to the weather, so the otherwise-static card has a little life. Rain and snow drift down, the sun’s rays shimmer, and cloudier skies softly breathe. It stays subtle by design and honors the system reduce-motion setting, switching off entirely for anyone who prefers no movement. Tapping it opens a larger panel floating over the card with the location, the condition spelled out, the current temperature, today’s high and low, the humidity, and a feels-like reading; a tap anywhere outside closes it. The weather is treated as a bonus layered over the clock: the date and time always render first, and if the forecast cannot be fetched the clock is unaffected, keeping the last good reading on screen or a quiet placeholder when there is nothing yet.

Integrations: The clock reads the Mac’s own time. The weather comes from Open-Meteo, a free public forecast service that needs no account or API key, refreshed every fifteen minutes while the panel is up. It is pinned to a fixed location saved in the app’s settings rather than following me around, so it asks for no location permission. Temperatures show in Fahrenheit by default, with Celsius a settings change away.

Claude Usage

Why I built this one: I do my work using Claude most of the day, and both my current session and my rolling weekly limits have ceilings I would much rather see coming than slam into mid-task. Knowing whether I can kick off something big or should start winding down is worth a permanent corner of the panel.

A live status panel for my Claude usage. It shows how much of my current session I have consumed on a rolling five-hour window and how much of my weekly limits I have used on a rolling seven-day window, both overall and broken down per model. Each bar shows a percentage and changes color as it fills, green when there is plenty of headroom, amber past about 70 percent, and red past 90, so a glance tells me whether to ease off. Each bar also shows when it resets, both as a friendly countdown and an actual time.

The per-model bars do not hard-code model names. The app reads them straight from my usage records and tidies them into friendly labels like Opus or Sonnet, so when Anthropic ships a new model it shows up on its own with no update needed.

It also keeps an eye on Claude’s own service health. If Claude is having problems on Anthropic’s side, the card surfaces it directly, gaining a colored border and a banner along the top, tinted yellow for a minor issue and red for a major or critical outage. Tapping the card while it is in that state opens Claude’s public status page. When everything is healthy the banner stays hidden and the card just shows my usage. That outage banner is a separate signal from the usage-source dot in the panel’s top status strip: one is about Claude being down, the other is about this machine’s view of my usage.

Integrations: Reads Claude Code’s local usage records on disk and refreshes them in the background, so the numbers stay accurate even when I am working entirely inside the editor rather than a terminal. It watches the data folder and updates the moment new usage is written rather than waiting for the next timed check. It only reads my own local data and never transmits or logs anything. Separately, it polls Claude’s public status page on a slow timer to detect outages; that check is public and uses no usage quota.

Window Control

Why I built this one: I run three monitors, and moving a window from the far end of the ultrawide up to a display two screens away is a long drag with a mouse. This is the fastest way I have to throw a window where I want it without touching the trackpad at all.

At rest the card stays calm: a “Focus:” line naming the app and window it will act on, with a single full-width Place Window button beneath it. Tapping that button grows a placement panel out of the button itself, floating above the card so it is never clipped by the tile.

The panel lays the options out by monitor, arranged to mirror my actual desk, the two Dells side by side on top and the Samsung below. Each display shows its friendly, editable name, defaulting to things like Dell Left, Dell Right, and G9, and those names are remembered against the physical display rather than a slot number, so they survive unplugging and replugging. Under each name are the placement choices, drawn as little schematic glyphs of that screen with the target area shaded in rather than as text labels: a full-width Full Screen bar that maximizes the window on that display, stopping short of macOS’s true full-screen mode so the menu bar and Dock stay reachable, plus region snaps. The two Dells offer a left half and a right half; the wide G9 offers a left-quarter, center-half, right-quarter split matched to how I actually arrange windows there. The touchscreen itself is excluded from the targets, since I would never want to throw a window onto the control panel.

One tap places the window and closes the panel; a tap anywhere outside dismisses it without doing anything. A long-press on a monitor’s name renames that display. A nice subtlety: even though tapping the panel technically steals focus, the widget acts on the window I was actually working in, not the panel. When the panel cannot do anything useful, the button’s spot explains why instead of opening, with a Grant Accessibility prompt when the permission is missing, “No other displays” when there is nowhere to send a window, or “No focused window” when nothing is focused. The action is optimistic: the button reacts instantly, and if the move somehow fails it flashes red and reverts rather than lying about success.

Integrations: Uses macOS’s Accessibility system to find and reposition the focused window. This requires a one-time permission grant, which the widget walks you through with a short onboarding panel, and a reminder that window titles are read locally only, never logged or sent anywhere.

Spotify

Why I built this one: putting the controls here means one less app taking up real estate on my main screens for something I only glance at and nudge.

A now-playing panel and remote. It shows the current song with album artwork, the artist and album, and a progress bar with elapsed and total time that I can tap or drag to scrub through the track. To the right sit enlarged back, play-pause, and forward buttons sized for touch. Below that it shows what is coming up next, and a scrollable list of my own playlists, each with its track count, that I can tap to start playing right away.

Behind the now-playing row, a soft wash of color sampled from the album art bleeds across the card and breathes slowly, so the panel quietly takes on a hint of whatever is playing. The color is pulled hard toward the muted charcoal-and-gold palette before it is used, so it only ever suggests the album’s mood rather than splashing it across the card, and it cross-fades from one track to the next.

It is considerate about state. While music is playing it refreshes about once a second so the progress bar moves smoothly, then relaxes to every few seconds when paused or idle to stay light. If Spotify is paused with nothing playing it says so plainly; if the Spotify app is not running it shows an Open Spotify button instead of dead controls. Actions feel instant because they update optimistically and then reconcile with what Spotify actually reports a moment later.

Integrations: Two sources working together. It reads the currently-playing track, artwork, and playback position directly from the Spotify desktop app on my Mac, and sends play, pause, skip, and scrub commands the same way, so the basic remote needs no sign-in at all. For the richer features, browsing my playlists and seeing the up-next queue, it connects to the official Spotify Web service through a secure sign-in, with the login stored in the Mac Keychain and refreshed automatically. The two halves are kept independent: if the playlist side hits a snag or I have not signed in, it shows a small Connect Spotify prompt in just that area while the now-playing controls keep working.

Pinned Apps

Why I built this one: the apps I return to constantly do not need to live in the Dock for me to reach them. Launching them from the panel keeps the Dock clean.

A personal launcher: a flush stack of large, touch-friendly buttons, each showing an app’s icon and name, separated by thin dividers so the list reads as one continuous strip. I curate the list myself. An Add button lets me pick an app, and a long-press on any row gives me an Unpin. A pin can be a plain “open this app,” or it can carry context, like a specific document that opens in its app, and those context pins get a small badge on the icon so I can tell them apart at a glance. One tap launches or jumps to it, with the row giving an instant tap response and a brief red flash on the rare occasion something fails to open.

Fixed at the very top of this list, above my pins, is a Meeting Notes row. It is not an app pin. I cannot unpin or reorder it, it never shows up in the Add picker, and it is a built-in switch that opens and closes Quick Capture Notes, described below, carrying a small indicator showing whether that window is currently open. It gets a distinct accent so it does not read as just another launchable app.

Integrations: Uses macOS to launch apps and open documents. The list of pins is saved locally and survives restarts.

Pinned VS Code

Why I built this one: I bounce between a lot of VS Code projects all day, and opening the right one is more friction than it should be. The recent-projects list is buried behind a menu, fills up with folders I opened once, and tells me nothing about a project’s current state. So before diving in I would often open the project first just to discover I had left it on the wrong branch or sitting on a pile of uncommitted changes, and with more than one GitHub account in play I could never quite remember which one was active. This widget puts my real projects one tap away and answers those questions before I open anything.

The same idea as Pinned Apps, specialized for my coding projects. It is a curated list of VS Code folders and workspaces, each shown with the right kind of icon, displayed as two-line rows with the project name on top and its path beneath; one tap opens the right one. I can add a target from a file picker, or use Pin Current VS Code Window to capture whatever I happen to have open at that moment, and the app works out whether that is a folder, a document’s folder, or a workspace.

Each folder row also shows live context: the project’s current Git branch, plus a small badge for how many uncommitted changes it has, or a quiet checkmark when the folder is clean, refreshed every few seconds while the panel is up. Along the bottom sits a footer showing which GitHub account is currently active; when I have more than one, tapping it lets me switch between them.

Integrations: Opens projects in VS Code, reads Git status directly from each project folder, and reads and switches the active account through the GitHub command-line tool. It watches the relevant files so the branch, change count, and account stay current on their own, even if I switch accounts in a terminal elsewhere. Switching the GitHub account here changes which account that tool acts as; it does not affect how my code pushes are authenticated.

Work Sets

Why I built this one: My work happens in recognizable setups. A coding project means VS Code on the big Samsung ultrawide, a terminal beside it, the app open in Edge on one Dell and a reference page on the other. Planning means a document front and center with Outlook, Teams, and a spreadsheet around it. Rebuilding one of these arrangements by hand every time, opening each app, hunting down each window, dragging it to the right monitor and sizing it, is exactly the repetitive fiddling this whole panel exists to eliminate. A Work Set captures one of these scenes once and rebuilds it with a single tap. It is the widget I lean on hardest.

A Work Set is a named snapshot of a working environment: which windows are open, what each one has open inside it, and where each sits across my monitors. I arrange the desktop the way I want it, tap Create Work Set, glance at the list of windows it detected, removing any stray ones and confirming which window is the primary one, give it a name, and save. The list of saved Work Sets looks and behaves just like the Pinned VS Code list next to it, which is why the two share a swipeable slot.

Tapping a Work Set activates it. It finds the windows that are already open, reopens the ones that are not, moves and sizes each onto its saved monitor and position, brings the primary window to the front, and minimizes everything that is not part of the set so the activated environment stands alone. That cleanup is fully reversible: the windows it tucked away come back when I reset the layout or switch to a different Work Set, and it only touches windows it minimized itself, so anything I had already set aside stays put.

It captures intent rather than rectangles on a screen. For each window it records what is actually open inside: the folder or workspace in VS Code, the folder in Finder, the document in a document app, the open files in Sublime Text, the active tab and profile in Edge, the working directory in Terminal. Restoring reopens that content, so I get back the working environment and not a set of empty apps. Because it keys off the content rather than fragile, momentary window numbers, a Work Set keeps making sense across restarts, and it remembers monitors by their actual hardware identity so saved positions survive unplugging and replugging a display.

A handful of touches make the live arrangement flexible without ever disturbing the saved snapshot. One window is the Focus Area, the primary spot where the real work happens, usually the big center monitor; a Switch to Focus button swaps whatever window I am in now into that spot, sliding the previous occupant back to where my window came from, so promoting a different window to center stage is one tap and never leaves windows stacked on top of each other. Rotate cycles the set’s open windows through their saved positions, for when I want the same windows but shuffled around the monitors. Reset Layout snaps everything back to the way the Work Set was saved.

A long-press on a Work Set opens a menu to Update Snapshot, recapturing the current arrangement into this set after reviewing what changed, plus Rename, Duplicate, Delete, and Details. Details lists every window in the set with what it has open and, after activation, an honest per-window status: fully restored, restored but with only partial content, placed but its content could not be reopened, still waiting for an app to launch, or not found. It never claims success just because an app happens to be running; if a window’s content could not be brought back, it says so and explains why.

Integrations: Uses macOS’s Accessibility system to capture, move, resize, and minimize windows, the same permission the Window Control and App Control Center widgets use. To recover what is open inside a window it reads VS Code’s and Sublime Text’s own saved session files and reopens projects and files through their command-line tools, and it uses AppleScript, which asks for a one-time Automation permission per app, to read Edge’s active tab and Terminal’s working directory. Window moves and swaps happen as a careful all-or-nothing operation that rolls back if part of it fails, so a botched move never leaves windows scattered. Everything is saved locally, and the saved snapshot deliberately avoids storing any momentary window identifiers so it stays meaningful over time.

App Control Center

Why I built this one: With three big monitors and a handful of apps that each sprawl into many windows, a dozen VS Code projects, several Outlook and Teams windows, a wall of browser tabs, macOS gives me no single, calm place to see what is actually open. Mission Control throws everything on screen at once and rearranges it every time, the Dock only tells me an app is running rather than what is inside it, and Cmd-Tab cycles through apps without showing their windows. The result is a lot of hunting: minimizing things to find what is behind them, or clicking through an app’s Window menu one entry at a time. This widget is my fix, a steady, always-visible map of just the apps I care about that stays put, so a single tap brings the right window forward or sends it to the right monitor.

A live overview of a curated set of apps, in my setup Finder, Outlook, Teams, VS Code, and Edge, and every window each of them has open, arranged in a tidy grid that packs cards together without leaving big gaps. Apps that are not running yet still hold their place as dimmed placeholder cards, so the layout stays put and I can launch them with a tap; a placeholder swaps to a live card about a second after the app starts.

There is real care in how windows are presented. Apps with several windows sit in a top zone I can drag to reorder; everything else sits below in a fixed order. The window I am focused on, and the app that is frontmost, are highlighted right where they are rather than jumping to the top, so the grid never reshuffles under me while I am using it. Each window carries a little colored marker for its state, focused, just visible, in the background, minimized, or full-screen, and the two-line labels surface the context I actually need to tell windows apart, pulled from each app: file paths, workspace names, browser tabs, or chat channels. Tapping a window brings it to the front, or minimizes it if it is already focused, and a long-press offers minimize, restore, or move to a specific display, which it carries out through the same machinery as the Window Control widget.

Integrations: Uses macOS’s app and Accessibility systems to see which apps are running and what windows they have. It refreshes about once a second, then quietly backs off to every few seconds when nothing is changing, to stay light on the system. Reading window details needs the same Accessibility permission as Window Control; without it, the widget still lists the apps and shows a prompt to grant access.

Timers and Stopwatches

Why I built this one: I keep needing to time things, and reaching for my phone or a menu-bar utility pulls me out of what I am doing. A stopwatch lives here so I can measure how long a piece of code, a query, or a build actually takes to run without setting up anything special. A countdown timer, set to auto-restart on a cycle, nudges me to stand up at my standing desk at a regular interval and then quietly starts itself again. Beyond those two, having several timers a tap away covers the small rhythms of a workday: time-boxing a focus block, remembering to step away and rest my eyes, or a plain reminder to come back to something in fifteen minutes. They all run side by side, and because they survive sleep and restarts I can trust them to still be right when I look back.

A board of timers and stopwatches I can run at once, up to three of each, all counting independently. Timers count down to zero; stopwatches count up. I can name each one, reorder them by dragging, and the layout adapts to how many I am running, showing one or two large and readable, or packing several into a compact scrollable list. The digits use a fixed-width typeface so nothing jitters as the numbers change, and switch between MM:SS and HH:MM:SS as needed.

The timing holds up under real conditions. Although the display repaints once a second, the actual time is always computed from fixed start and end moments rather than counted tick by tick, so it never drifts and stays correct straight through a Mac sleep or an app restart. A timer that finishes while the Mac is asleep simply shows as done the moment I look. When a timer completes it goes red with a pulsing border; tapping it acknowledges and restarts. Timers can also auto-restart on a cycle, with a choice of immediate or a short delay of 5, 10, or 30 seconds, a visible restart countdown between rounds, and a cycle counter so I can see how many times it has looped.

Integrations: None beyond the Mac’s clock and its system alert sound. Completed timers can chime with the standard macOS alert, with a global mute toggle in the footer plus a per-timer override, and the sound plays without interrupting whatever else I am listening to. Everything is saved locally so it all survives a restart.

Quick Capture Notes

Why I built this one: Almost all of my meetings involve taking notes while a video call fills the screen, and none of the usual options fit my desk. A notes app on a side monitor means turning away from the person I am talking to; a floating window on top of the call covers the video. My big center display is a 5120 by 1440 Samsung ultrawide, the G9, wide enough to sit a meeting window up top and a note-taking strip directly beneath it, both fully visible. This feature is that strip: a proper keyboard note-taking surface that docks under the meeting so I can watch and type without looking away.

Unlike everything else in this app, Quick Capture Notes does not live on the touch panel. It is a normal desktop window I open with a keyboard and mouse, and it always appears on the G9. I open and close it from the Meeting Notes switch at the top of the Pinned Apps list. When it opens it docks as a wide, short strip directly beneath the meeting window, taking that window’s width and filling the gap between it and the Dock, so the video call and my notes are both fully visible without overlapping. If the G9 happens to be unplugged it opens on whatever display is available and quietly slides back onto the G9 the moment that screen reappears. The window stays freely movable and resizable, and it remembers where I last left it so it comes back the same next time.

Inside, it is a three-pane Markdown workspace. On the left is a list of my notes, newest first, grouped under sticky day headers labeled Today, Yesterday, or the date, each entry reading as a friendly title derived from the note itself. In the middle is an editor where I type plain Markdown in a monospace font with soft wrapping, focused and ready the instant the window opens. On the right is a live preview that renders the Markdown as I type. The wide strip is what makes showing both at once practical.

The editor and preview scroll in lockstep: scrolling one moves the other so the same content stays lined up across both panes. Because rendered headings, tables, and code blocks take up wildly different amounts of space than their source text, the lock tracks which line of my writing each rendered block came from rather than naively matching a percentage, so the right paragraph stays aligned even around a big table or code fence.

A few things make it pleasant to actually take notes in. It saves itself, with no save button; edits are written to disk a beat after I stop typing, and flushed whenever I switch notes, start a new one, or close the window, so nothing is ever lost. Notes name themselves: each note becomes a Markdown file named with its creation date and time plus a short slug taken from its first line, so my notes sort chronologically and are easy to find outside the app. The name is minted once the first line is settled and then left alone; if I want to refresh it after rewriting the title, an Update Filename action re-derives the slug while keeping the original timestamp so the note stays put in the list. Lists continue themselves, so pressing Return inside a bullet, numbered, or checkbox list starts the next item automatically, numbers incrementing and checkboxes resetting to unchecked, and pressing Return on an empty item ends the list. Short snippets expand: typing a small trigger followed by a space turns ;ai into a checkbox action item, ;q into a “Question:” quote, and ;d into a bold “Decision:” line, and the set is small and easy to extend. The Markdown it renders covers what notes actually need, headings, bold and italic, inline and fenced code, bulleted, numbered, and checkbox task lists, links, blockquotes, tables, and horizontal rules; anything outside that shows as its literal text rather than breaking. I start a fresh note with a New note button or ⌘N, and remove one from a right-click Delete that moves the file to the Trash.

Integrations: Notes are plain .md files in a folder on my Mac, one file per note, so they are readable and editable by anything else, and the app watches that folder so if another tool writes a note into it the list updates on its own, and if a note I am not actively editing changes on disk, it reloads. The Markdown preview is rendered by hand-written code with no outside libraries, keeping the app self-contained. Nothing here leaves the machine.

The Razer Naga side buttons

Why I built this one: The panel is fast, but reaching for it is still reaching. The window placements I use most should be under my hand already, and my mouse has twelve side buttons sitting unused.

Beyond the touch panel, the app turns those twelve buttons into instant window-placement shortcuts, so I can throw the window I am working in onto a specific monitor and position without touching the panel at all. It reuses the exact same window-moving machinery as the Window Control widget; only the trigger is different. Getting the Mac to tell the difference between a Naga side button and ordinary typing was its own fight, and that story belongs to the build log rather than here.

The buttons map to placements the way my desk is laid out. The first three snap the focused window to the left quarter, center half, or right quarter of the G9; the next three fill the left half, whole, or right half of the left Dell; the following three do the same on the right Dell; and another maximizes the G9. One more button is bound specially, to a fixed size and position rather than a screen region: a single press drops whatever I am in exactly into my meeting spot, high on the monitor and close to the webcam, so my eyes sit near the camera and I read as making eye contact instead of gazing off. That position is also what leaves the band underneath free for Quick Capture Notes to dock into, so one press sets up the meeting and the notes together. A press acts on the window I am actually focused on, whatever app it belongs to, and does nothing harmful when there is no window to move or the target monitor is not connected.

Integrations: Reads the mouse’s buttons through macOS’s input-monitoring layer and moves windows through the same Accessibility permission the window features already use. It runs app-wide the whole time the app is open, regardless of whether the touch panel is on screen, and stays dormant and harmless until both permissions are granted.

Design notes

The look is deliberately understated: a muted charcoal palette with a single gold accent, in both light and dark mode following the system setting. This is a support surface sitting below my main monitors, so it is designed to be calm and glanceable rather than to compete for attention. Everything is tuned for touch, with generous button sizes, comfortable spacing to avoid mis-taps, and a quick visual ripple on every tap to confirm it registered, since the screen has no physical click or vibration.

The gold accent quietly warms with the time of day, all on its own with nothing to set. It eases toward a cozier amber through the evening and overnight, then returns to its daytime gold by morning. The shift is gradual and gentle enough that you would never catch it moving, just a panel that feels a touch warmer at night, and it is tuned to stay readable so the dark text on gold buttons keeps its contrast around the clock.