Five releases, one update.
v1.8.1 fixed the drag and drop insertion line, which drew exactly the list's scroll offset too high on a scrolled sidebar. v1.8.2 is what the manual test pass for the live CLI release produced: the daemon had refused every request from the desktop app since v1.8.0 while a silent in-process fallback hid it, closing the app on Windows left an invisible process that swallowed every later launch, the Windows autostart flashed a console window at every login, and Core Session retired to macOS-only rather than pretend platform parity. v1.8.4 closed the gap one step earlier: the Storestation switch could say ON while nothing was running, because the app only ever connected to a daemon and never started one. Now, when nothing answers the socket and the switch is on, the app brings its bundled daemon up and connects again. The same release removed the splash window: the main window shows from process start, paints the real shell colors on the first frame, the sidebar flashes placeholder rows until your workspaces land, and the terminal engine loads when the first panel mounts, so the app's first parse is about a third of what it was. v1.8.5 closed the hole that first frame opened on macOS: a saved fullscreen state restored at window creation put the window off every Space, so the process ran while nothing showed. Fullscreen is now session-local on macOS. v1.8.6 fixed what living with the self-heal exposed: a daemon recovery restarted the daemon's id counter at its base, so fresh panels minted identities still held by live panels and two terminals shared one route. The counter is process-global now, and the app no longer deletes the daemon's socket files on exit.
Key facts
- Versions: v1.8.1, v1.8.2, v1.8.4, v1.8.5 and v1.8.6, shipped across one update window
- The daemon routing bug ran since v1.8.0 on all three platforms
- The zombie process and the autostart flash are Windows-only
- Core Session: macOS-only as of v1.8.2; on Windows and Linux the daemon refuses it with a clear code, Settings keeps only the Core (Always-On) switch
- The daemon self-heal covers the two ways a daemon disappears: a reboot on a machine without autostart, and a crash
- Only the offline outcome triggers a start; version-gate refusals and transport errors keep refusing honestly
- The splash window is removed on all three platforms; the main window is visible from process start
- The terminal engine loads on the first panel mount instead of at boot
- On macOS, fullscreen state is session-local: never saved, never restored at window creation
- As of v1.8.6, daemon panel ids never repeat within the app's lifetime, and the daemon's socket files survive the app exiting
- Ships inside the normal installers; the built-in updater picks it up
What changed
The line points where you point (v1.8.1). On a scrolled list the drag insertion line drew exactly the scroll offset too high, because the math ran in viewport coordinates while a scrolled container positions children in content coordinates. One shared conversion now serves the sidebar's line and the tab bar's line, drag geometry re-measures on every pointer move, and a scroll listener re-targets the drop mid-drag when the wheel moves rows under a stationary cursor.
The daemon hears the app again (v1.8.2). The desktop app and the daemon share one connection, and that connection declares itself an executor at hello. The daemon refused every operation from an executor connection, so each panel open came back "unknown op" and a silent fallback routed the work in-process: everything looked fine, and the daemon owned zero sessions on every platform since v1.8.0. The one-connection design always meant that connection to be both the session driver and the gateway executor, so the refusal contradicted the architecture it sat in. Now one connection runs the full daemon catalog beside its forwarding duty, and the split is unambiguous by construction: answers get relayed, requests get dispatched.
Windows closes properly (v1.8.2). Closing umux destroyed the main window but left the process alive with no visible window, and every later launch was silently swallowed by the single-instance forward, so "the app won't start" really meant "the app is already running somewhere, windowless." A hidden banner window that lives for the app's whole lifetime kept the event loop from ever reaching zero windows, so exit-on-last-window never fired. When the main window is destroyed the app now exits cleanly.
Windows autostart goes windowless (v1.8.2). The autostart entry wrapped nothing: a bare launch flashed a console window at every login and kept it on screen. The entry now wraps the daemon in a headless console host, and the app rewrites legacy entries to the wrapped form on its own.
Core Session says which platforms it works on (v1.8.2). The timed-awake feature is retired to macOS-only. On Windows and Linux the daemon refuses a session start with a clear code instead of pretending, a leftover session record is discarded cleanly at daemon restore, and Settings on those platforms keeps only the Core (Always-On) switch.
The app starts its own daemon (v1.8.4). The lazy connect used to have one move: try to connect, and on any failure fall back in-process with a short backoff. That fallback exists for a good reason, a missing daemon must never block opening a terminal, but it also meant the switch's promise depended on somebody else starting the daemon. The diagnosis on a Mac from our own test set made the shape obvious: the store said OFF, the app's own socket mirror answered the status probes, the daemon owned zero sessions, and the daemon binary itself ran fine in an isolated store. Healthy engine, missing starter. The rule now: offline is the one failure a start can fix, so when nothing answers and the switch is on, the app spawns its bundled daemon and connects again. Everything else keeps refusing. A version-gate refusal or a transport error describes a socket that is already served, and starting something new into it can only collide. A failed bring-up falls back in-process exactly like before, so no open ever blocks.
The first second belongs to the app (v1.8.4). The splash window is gone, and its story is worth telling: it showed a small window and held it for two extra seconds after the app was ready, a deliberate choice so people would actually see it. This release deletes the whole arrangement. The main window is visible from process start, the system paints it in the app's real colors before any webview exists, and a tiny dependency-free skeleton inside the page draws the shell's shape while the code parses. The sidebar flashes placeholder rows until the workspace store lands, with a shimmer that steps aside for reduced-motion settings. Nothing artificial delays the window anymore.
The invisible window (v1.8.5). The new boot then met a Mac that had gone fullscreen under the previous install. The saved window state carried fullscreen:true, and the restore ran at window creation, before anything could show: on macOS that window landed off every Space. The process ran, no window appeared anywhere, and the single-instance forward swallowed every relaunch, so "the app won't start" meant "the app is running fine and hiding". The fix is a policy, not a patch: on macOS fullscreen becomes session-local, never saved and never restored at creation, while Windows and Linux keep the plain restore. A saved state is a promise about a screen you have not seen yet, and the first frame should never keep a promise it cannot show.
The recovery that crossed the wires (v1.8.6). Living with the self-heal exposed the last defect in the chain. A daemon recovery creates a fresh daemon driver inside the app, and that driver restarted its panel id counter at the daemon id base. Ids minted by the previous driver still belonged to mounted panels, so after a recovery the fresh panels minted identities that were already taken: two terminals on one app id. Keystrokes typed in one landed in the other's session, and both tabs' folder chips followed one shared working directory. The fix is a policy with no exceptions: the id counter is process-global, and an id already given is never given again, however many times the daemon recovers. The same v1.8.6 pass fixed the app's exit path, which deleted the gateway socket and pid files unconditionally on the way out. With Storestation on, those files belong to the daemon process, which outlives the app; deleting them left a live daemon deaf, its listener holding an unlinked path while every later probe answered "not running". The cleanup now runs only when the gateway actually served the files.
The terminal engine catches up in the background (v1.8.4). The terminal library used to ride in the app's first parcel: the whole thing parsed before the first frame could show. Now it loads when the first panel mounts, a moment after the first paint, and the window's first parse is about a third of what it was. The engine arrives from the module cache on every later mount, so it loads once. You open the app and the terminals arrive while it is already on screen, which is the whole point of the app.
Why it matters
A failure that announces itself costs one bad day. A failure that keeps up appearances costs every day after it. The daemon routing bug was the pure case: every symptom was quietly explained away by a fallback that existed for a good reason, so the product looked finished while a whole subsystem answered nothing. And the same shape returned twice more in disguise. The self-heal's resilient fallback that kept panels opening without a daemon is what hid the missing starter, and it took a real machine, a real report, and a status probe that answered "app" where a daemon should be to see it. The fullscreen restore was a state file telling the truth about a screen that no longer existed. The fixes stay inside the design rather than around it: the honest refusals keep refusing, the one failure a start can fix gets a start, and the boot paints instead of hiding. Where a feature genuinely works, keep it everywhere you can. Where it does not, refuse with a clear code. And restore only what the user can see; let everything else wait for a keystroke.
FAQ
Did the daemon routing bug break anything users could see?
Sessions still worked, because the in-process driver did the same work locally. What never happened was the point of the daemon: no session survived anything, because the daemon owned none. That is also why it hid so well.
Does anything change when the Storestation switch is OFF?
No. With Storestation off, panels open in-process exactly as before, and nothing gets started. The self-heal only acts when the switch is on and nothing answers the socket.
What if the daemon cannot start at all?
The open falls back in-process, the same honest fallback as before, and the Settings status shows the daemon offline. A missing daemon still never blocks opening a terminal.
I went fullscreen on v1.8.4 and the app stopped launching. Is this that bug?
Yes. v1.8.5 fixes it, and an existing install heals itself on the first launch after the update: the saved fullscreen state is simply no longer applied on macOS. Until then, deleting the app's saved window state also unblocks the current version.
How do I get the update?
Through the built-in updater, or grab an installer from the release page. Links below.
Links
- Latest release: https://github.com/CrystalPlatforms/umux/releases/tag/v1.8.6
- Project and installers: https://github.com/CrystalPlatforms/umux

