• Windows app (id 12): live preview of two sample windows, a colour picker and an inspector (chrome kind, geometry, title bar gradient, buttons, body, shadow, motion, nine colour schemes); every control restyles all open windows at once.
• WinStyle: ws[] in desk3/01-core.HC, drawn by desk3/01-winstyle.HC, edited by desk3/03e-windowstyle.HC. -1 follows the desktop style, so defaults are pixel identical to before (Aiwnios, five styles, measured).
• Themes: the five styles are read-only bases, Customize makes an editable copy; Export prints ws1 ... on COM1 and B:/WINSTYLE.TXT, Import reads it.
• Minimise and maximise buttons now exist (minimise closes with its own animation). Aiwnios: avoid A(1)<=x<A(2) chains.
• Details, numbers and limits: docs/apps/window-style-editor.md. Screenshots: shots/window-style-*.png. Not run on the x86 VM yet.

Icon Style Editor (2026-10-27)#

• The Icons app (desk3/03c-iconstyle.HC, key i or the paintbrush in the dock): a live preview of every app icon at three sizes on light and dark backdrops, and ten pages of controls (shape, fill and gradients, colour schemes, tone, bevel and gloss, shadows, glyph, border and glass, glow and grain, dock layout), eight presets, Export and Import of a one-line style string (KSI1 rd50 sq1 ...) through Notes.
• One style, one function. is_v[] is the style; DrawIconTile(x,y,size,app,state) draws for the dock and the preview. The default style draws exactly as before; any other is built once per (app, size, signature, state) into cached colour tiles from shared alpha planes and blitted per frame. docs/apps/icon-style-editor.md has the controls, the format, the numbers and the limits.
• The dock calls the renderer through the pointer ks_ictile (forward declared calls do not reach a later definition). Works on Aiwnios unchanged; aiwnios/drive-icons.HC is a headless driver. Screenshots: shots/icon-style-*.png.

Dock backdrop and Monitor (2026-10-27)#

• Translucent dock. The pill is a 205-alpha tint over a blurred copy of what is actually behind it: wallpaper and any window under the dock. Outside the rounded shape nothing changes (no rectangle). The backdrop is sampled every fourth pixel, box blurred and enlarged by four (DockBackdrop), and recomputed only when the scene in the dock band changes; the dock's own redraws (hover, magnification, icon size) reuse it. DockGlass composites it through the corner coverage, so the edges are anti-aliased at 1x and 2x. Cost at 2x: the rebuild is about 2.4 ms (shown as "Dock backdrop" in the Monitor; 0.7 ms at 1x); a warm dock sweep is 3.4 ms, against 3.1 before.
• Monitor. The graph takes one sample per 100 ms of wall time (the largest frame in that time, 0 when idle) on a fixed 0 to 50 ms scale, drawn as an anti-aliased line that scrolls between samples. An open Monitor redraws only its numbers and graph, ten times a second, instead of the whole window once a second.
• Settings and Monitor pixel readouts show the real screen size (they read the window width while a window was being drawn).

Screenshots: shots/fix-*.png.

Boot experience (2026-10-27)#

scripts/run.sh /path/to/TempleOS.ISO opens the QEMU window on the Kosmos splash: a near-black screen, one mark (a ring with a dot set into it) and a thin loading bar, then a 600 ms crossfade to the desktop (a cut when Settings, Animations is off). The TempleOS terminal is never shown.

How: the desktop is loaded and compiled once into a saved VM image (scripts/build-image.sh, about 2.5 minutes, headless; savevm splash) with Main parked on the splash at 0 percent. run.sh starts QEMU with -loadvm splash and sends a go byte over the serial port (scripts/ks-go.py). The guest then does the real remaining start-up work, with the bar following it: icons, window state, the wallpaper (about 1.4 s, reported row by row), the first frame; it then fades from the splash to that frame. The image lives in ~/.cache/kosmos-os/desk3-s<scale>.qcow2 (not in the repo); run.sh builds it on first use and rebuilds it when desk3/*.HC or the assets change. KS_S, KS_W and KS_H each get their own image. Display changes in Settings work as before (the splash code is not used again after start-up).

Keys: T on the splash shows the original TempleOS screen (the 640x480 gr.dc2, enlarged 3x at 2880x1800, 1x at 1440x900, on a dark ground); F12 returns to Kosmos, from the splash and also from the desktop (F12 on the desktop opens the original view at any time). R on the splash restarts: QEMU is started with -no-reboot, the guest tells run.sh over serial, and run.sh reloads the image. The Kosmos menu (top left): Restart reruns the whole session through the splash (a full guest reset that run.sh reloads from the image, because the desktop state cannot be rebuilt cleanly in place; if Notes were edited the row first asks once, as Notes live in the RAM drive that a restart reloads; outside run.sh it ends at the TempleOS prompt), and Quit Desktop opens the original TempleOS view (F12 returns). In the original view keys go to a TempleOS terminal (forwarded by Kosmos), the pointer is the TempleOS pointer.

Cold path (old behaviour, about two minutes, the TempleOS terminal is visible while the files go in): KS_COLD=1 scripts/run.sh ISO. The dev loop is unchanged: scripts/snap.sh, then KS_S=2 KS_MODE=desk3 KS_RESTORE=1 scripts/send-to-vm.sh (it shows the splash too, with KS_PARK=0). KS_PARK=1 is only for building the image.

Measured (QEMU on Apple Silicon, 2880x1800): from QEMU launch to desktop ready about 3.6 s with the image, of which about 1.9 s was the guest's start-up work after the go byte plus the 0.6 s fade (after the performance pass below the guest work is 0.56 s, KS-READY 1.5 s after go, as the wallpaper now builds in about 60 ms); the cold path is about 2.5 minutes after the 50 s boot. Drag benchmark after the change: 9.5 ms a frame (unchanged). Screenshots: shots/boot-*.png. The splash crossfade uses the two-source blend KsLerpRow (LerpRow); the KsMix3 routine this work first added was the same loop and was merged into it (see the performance pass below, which also replaced the style crossfade with a blend of two snapshots).

Window and animation performance pass (2026-10-27)#

Branch perf/window-animation-speed. Everything below was measured in QEMU (TCG, x86-64 emulated on an Apple Silicon Mac) with the benchmark suite behind the b key: each scenario renders real frames through Render and records the average and worst frame; the Monitor app (key 6) shows the table and the same lines go out on the serial port (bench|name|avg|worst|frames|phase split, tenths of a millisecond). t runs a self-test that checks every assembly routine against the HolyC formula and times the big copies.

Before and after, milliseconds a frame (average / worst)#

The drag number varies between 5.0 and 5.6 ms from run to run (three runs of the final code); the phase split of a 5.6 ms frame is wallpaper 1.1, windows 2.7 (shadow 1.2, layer copy 1.5), copy to the card 1.5.

What changed, in the order it was measured#

1. Copy32 on an unrolled 64-byte MOV loop (KsCpu): a 2880x1800 copy takes 15.7 ms against 52.5 ms with REP MOVSQ (the copy to the video card is 4.0 ms either way). Every wallpaper, layer and card copy uses it.
2. Wallpaper build (BuildWall, Up4, BoxLow): 1830 ms to 70 ms. The gradient and blobs are computed at a sixteenth of the native size in HolyC (20k pixels), enlarged by four in assembly (KsLerpRow down the rows, KsUp4H along them, the same bilinear maths as before), box blurred by an assembly sliding window (KsBox8, eight taps each way, edges repeated), and enlarged by four again. The picture is the same to the eye (screenshots compared); the blobs are a touch smoother.
3. Style crossfade from two snapshots: SetStyle keeps the old screen in prev, Render draws the new one once into nxt, and every crossfade frame is bb = prev*k + nxt*(1-k) in assembly plus the copy to the card, instead of a full redraw and a HolyC Mix per pixel. 277 ms to 60 ms a frame at 2x, 16 ms at 1x. The 25 ms target is missed at 2x: the blend of 5.2 million pixels is 53 ms of pure instruction count (about 11 instructions a pixel; TCG runs close to one guest instruction a nanosecond on this Mac). A four-pixel SSE2 version, byte-encoded because the TempleOS assembler has no SSE opcodes (CR4.OSFXSR set by hand), gave the right pixels but took 83 ms: QEMU runs the packed integer instructions through helper calls. Dropped.
4. Icon masks in integer arithmetic (SegMask, DistTab): the stroke rasteriser projected each pixel onto each segment with x87 floating point and a Sqrt. It now works in sixteenths of a pixel, one division a segment, and reads the coverage from a squared-distance table per icon size. Eleven dock icons at 64 px: 2.8 ms, against about 11 ms each before, so a dock size seen for the first time no longer hitches (cold sweep worst 117 ms to 5 ms).
5. Retained window layers with damage (LayerBuild, Composite, Damage*): each open window keeps its chrome and body in a bitmap and is rebuilt only inside its damage rectangle; content changes call Damage (whole window), DamageL (a rectangle: hover highlights, the Viewport animation, the Notes text area, the Files list, the title bar on a focus change), while moving, raising and shadow animation only expose (DirtyWin) and copy the layer. Hit regions are stored per window and replayed each frame. The corners blend through the corner coverage table so they stay transparent over the shadow. Drag 7.9 to 5.1 ms, drag small 9.9 to 3.4, open and close 7.8 to 5.8, focus change 15.0 to 9.1, full redraw 25.5 to 19.0.
6. Opaque hole: the topmost window shown from an opaque layer overwrites its inner rectangle, so the wallpaper and the layers under it are not copied there (the opaque-region idea of Weston and wlroots). Small on its own (wallpaper 1.3 to 1.0 ms in a drag) but free.
7. Cached shadow tiles and corner tables: ShadowTile kept one (radius, blur) tile and CornerTab one radius, both built with a Sqrt per pixel; a frame that drew the dock and a window rebuilt both, and the magnified dock asked for a dozen radii. Four tiles and one table per radius are cached: dock sweep 12.3 to 2.7 ms, full redraw 19.7 to 14.0.
8. ToFront dirties the raised window and the two title bars instead of every window: open and close worst frame 23 to 9 ms.

Merged with the boot splash work: its KsMix3 blend was the same two-pixel loop as KsLerpRow (same maths, same instruction count), so one copy was kept, KsLerpRow, because the self-test checks it and Up4 uses it; SplashFade calls LerpRow. Its BoxLow, Up4 and BuildWall progress hooks (SplashTick) were carried into the new assembly-based versions.

Tried and dropped: SSE2 (above). Not done: -smp with worker tasks (not measured; the remaining per-frame cost is copies and blends that would need the work split by row band, and TempleOS task switching under MTTCG is untested); a real backdrop blur for the glass style; pixman's exact divide-by-255 in the blend routines (our alpha runs 0 to 256, so 256 is exactly opaque and coverage 255 lands 0.4 percent short, which is below what the eye sees; the fix costs two instructions a lane).

Idle: with the default desktop (Projects and the animated Viewport open, nothing else happening) QEMU uses about 36 percent of one core after this pass against 38 to 49 percent before, and 8 percent at the bare TempleOS prompt; the Viewport redraws its scene 30 times a second (about 3 ms each at 2x) and the loop wakes every 5 ms to poll the mouse and keyboard. Near zero was not reached; closing the Viewport, or sleeping longer when no window animates, is the next step. The main loop sleeps 5 ms when nothing is dirty and otherwise paces to the frame cap (60, or 30 in Settings, Display; QEMU refreshes its window about every 30 ms, so 30 is enough for a shown frame).

Ideas read in compositor sources (MIT, ideas only, no code copied): the per-node damage of wlroots wlr_scene (https://gitlab.freedesktop.org/wlroots/wlroots, types/scene/wlr_scene.c) and the opaque regions and damage merging of Weston (https://gitlab.freedesktop.org/wayland/weston, libweston/compositor.c) are what the layers, Damage* and the hole implement; pixman (https://gitlab.freedesktop.org/pixman/pixman, pixman-combine32.h) for the divide-by-255 note above. Hyprland (GPL-3) was not read.

HolyC traps met in this pass: global arrays without an initialiser are not zeroed (a cache of pointers held garbage), a new global pointer must be nulled before its first Free, ks_hx0 was already the hit-region array (name clash gives "Invalid lval"), and anything printed from inside the renderer has to go out on COM1 because the screen is in VBE mode.

Scripts: KS_TVM (state directory, default /tmp/tvm) and KS_SERIAL_PORT (default 4555) let two VMs run side by side; boot-vm.sh records its pid in $KS_TVM/qemu.pid, stop-vm.sh kills only that one, shot.sh NAME screenshots to $KS_TVM/NAME.png.

Renderer performance pass (2026-10-27)#

Dragging the Projects window at 2880x1800 (press b in the desktop; the Monitor app shows the result) went from 72.1 ms to 9.5 ms a frame. Measured in QEMU on an Apple Silicon Mac, 40 drag steps, redraw rectangles merged as in normal use:

What changed, each measured first (spike/KsBench.HC, spike/KsBlend.HC, run with KS_MODE=bench or KS_MODE=blend): - TempleOS MemCpy is REP MOVSB: 2392 ms for 168 MB. REP MOVSQ takes 321 ms (7.5x). MemSetU32 is REP STOSD (62 ms); an unrolled store loop takes 12 ms (5x). Copy32 and Fill32 in desk3/01-core.HC use them. - Blending in HolyC costs about 31 ns a pixel because of the code the compiler emits; the same maths in assembly, two pixels a pass, costs under 1 ns a pixel (0 mismatches against the HolyC formula). KsBlendRow, KsBlendCol, KsBlendA and KsBlendA2D do constant-alpha spans and columns, per-pixel alpha rows, and 2D alpha blocks. - Shadows were 42 of the 46 ms: a per-pixel function-call loop. They are now constant-alpha rows and columns plus a cached corner tile (2.8 ms). - Glyphs, Lucide icons, disks and rounded corners use the 2D alpha blit, so no function call per pixel. - Windows that miss a redraw rectangle are skipped after the first pass of a frame.

Remaining cost is mostly app bodies (2.5 ms), window chrome (3 ms) and the two copies (3.6 ms). Next candidates: retained window layers with tile damage, and -smp with worker tasks.

Kosmos Temple Desktop 3 (retina, Settings and more apps)#

desk3/*.HC is the current desktop. It draws in logical units (1440x900) at a scale of 1 or 2, so retina is a real 2880x1800 framebuffer with every shape and glyph rasterised natively (Inter atlases for both scales in assets/KSFONT.BIN). Only the rectangles that changed are redrawn and copied to the card, so an idle desktop costs nothing and a moving window costs about 25 ms at 2880x1800. Window corners and shadows are anti-aliased and the shadow follows the rounded shape, so corners are truly transparent; the glass style clips its blurred backdrop to the same shape.

Icons are Lucide (ISC, notice in assets/LUCIDE-LICENSE.txt): scripts/gen-icons.py flattens the SVGs to strokes in assets/KSICONS.BIN, and the desktop rasterises them as anti-aliased strokes at any size, cached per size. Plan for the rest of the OS apps: docs/core-apps-plan.md.

The TempleOS app mirrors the real TempleOS screen (its 640x480 gr.dc2 buffer) into a window, so any TempleOS program runs for real: in Files, select a .HC file and press Run, or click it twice (other files open in Notes). The program runs in its own terminal task; while the window is in front the keyboard goes to it and the pointer is mapped into 640x480. Close the window to stop it.

Apps: Files (browses the real TempleOS drives and Demo, Apps and Doc folders), Projects, Notes (a text editor that saves to B:/NOTES.TXT), Calculator, Monitor (frame times and redraw cost), Viewport, Palette, Scene and Settings. Settings: Appearance (five themes with previews, accent colour, wallpaper), Display (resolution, 1x or 2x retina, frame cap; Apply switches the running desktop), Dock (icon size, magnification, indicators, translucency), About (system info, animations, frame time, corner radius, restart). Settings are not saved: the live CD has no writable disk.

Run it (about two minutes; pass the TempleOS V5.03 ISO): scripts/run.sh /path/to/TempleOS.ISO Keys: 1 to 9 and 0 open apps in dock order, Tab brings the back window forward, s cycles the style, r toggles retina, p the next Settings page, b runs the benchmark suite, t the renderer self-test, f forces a full redraw, Esc reboots. Notes and Calculator take typing when in front. Mouse: click, drag title bars. The QEMU window is 2880 points wide at 2x; resize it (zoom-to-fit) so each guest pixel lands on a screen pixel. Measured in QEMU on an Apple Silicon Mac (x86 emulated): 7 ms per redraw at 1440x900 for the animated Viewport, about 25 ms at 2880x1800; the first switch to a theme at 2x pauses about 0.3 s while its wallpaper is built. Quick edit and test: scripts/snap.sh saves a booted snapshot with the font in it, then KS_S=2 KS_MODE=desk3 KS_RESTORE=1 scripts/send-to-vm.sh loads new code in about 20 seconds. Port research for running kosmos-app inside this desktop: docs/kosmos-app-port-research.md.

Kosmos Temple Desktop 2 (1440x900, 32-bit colour)#

KsDesk2.HC is the version that matches apps/os-styles: Inter text, anti-aliased rounded windows, soft shadows, a blurred wallpaper behind a translucent menubar and floating dock, five styles, window open and close animations, a dock that magnifies icons toward the cursor, and a crossfade when the style changes. Screenshots: shots/desk2-*.png.

How it works, with no kernel patch: QEMU standard VGA is switched to a linear 1440x900x32 framebuffer through its Bochs VBE ports (0x1CE and 0x1CF), the framebuffer address comes from PCI BAR0, and the desktop keeps its own back buffer, draws everything itself in HolyC and copies the frame to the card each time (the VGA bank register is moved past the visible memory so the TempleOS text compositor cannot scribble on the picture). TempleOS stays underneath as the runtime for HolyC, timers, files and input. The mouse is read as relative motion, because the system mouse is clamped to 640x480. Esc reboots.

Run it (about two minutes; pass the TempleOS V5.03 ISO):

scripts/run.sh /path/to/TempleOS.ISO

Keys: 1 to 4 open an app, s cycles the style, Esc quits. Click the dock to open, focus or close an app, drag title bars. Apps: Projects (click a row), Viewport, Palette, Scene. Styles: Longformer light and dark, macOS, Windows 11, Kosmica glass.

Measured in QEMU on an Apple Silicon Mac (x86 emulated): about 30 to 40 ms per frame at 1440x900 with four windows, so 25 to 30 frames per second. A full-screen copy is about 7 ms and a 64000 pixel HolyC loop about 1 ms (spike/KsSpike.HC). 2560x1600 works (KS_W, KS_H and KS_VGAMEM=32, see scripts/run.sh) but frames take about three times as long. Limits: only works on the QEMU standard VGA card; the glass style blurs the wallpaper, not the windows underneath; the text atlas is Inter (SIL Open Font License) at four fixed sizes, rasterised by scripts/gen-font.py into assets/KSFONT.BIN; rebuilding it needs Pillow and the Inter TTFs. For quick edit and test cycles, scripts/snap.sh boots once and saves a VM snapshot, then KS_MODE=desk2 KS_RESTORE=1 scripts/send-to-vm.sh reloads in about 40 seconds.

Kosmos Temple Desktop (custom drawn)#

KsDesk.HC is a desktop that paints itself, to match apps/os-styles: menubar with a clock and a style pill, windows with title bars and rounded cards, and a floating dock with running dots and hover labels. One full-screen TempleOS window draws everything from a draw_it callback and reads the mouse (ms.pos, ms.lb) and keyboard in its own loop, so Esc, mouse clicks and dragging all work. Five styles reprogram the 16-colour palette and pick a window chrome: Longformer light and dark, macOS (traffic lights), Windows 11 (caption buttons), Kosmica glass. Apps: Projects (click a row), Viewport, Palette, Scene.

Run it (about four minutes, the files go in over the serial port; pass the TempleOS V5.03 ISO):

scripts/run.sh /path/to/TempleOS.ISO

Keys: 1 to 4 open an app, s cycles the style, Esc quits. Click the dock to open, focus or close an app; drag title bars. Screenshots: shots/desktop-*.png. Limits: 640x480 and 16 colours, an 8x8 bitmap font, no anti-aliasing; the TempleOS title bar and border still frame the screen. The older tiled-window shell (KosmosShell.HC, KsLib.HC) loads with KS_MODE=shell scripts/send-to-vm.sh.

Kosmos Temple Shell (HolyC, runs inside real TempleOS)#

Tiled app windows above a persistent launcher bar, written in HolyC against the official TempleOS V5.03 sources (Adam/Win.HC for WinHorz/WinVert/WinToTop/WinMax, Demo/DolDoc/MenuBttn.HC, Demo/Graphics/Life.HC for the draw_it idiom). Tested in QEMU on this Mac. See shots/.

What it does#

• The terminal you start it from becomes the bar, pinned to the bottom 4 text rows: Projects Viewport Palette Scene | Tile Close Quit. A star marks an open app.
• Each app opens in its own terminal window and the tiler re-flows all open apps into a grid above the bar (1 app full, 2 side by side, 3 and 4 in a 2x2, the last row stretches).
• Projects: the 17 kamiji projects as a menu, green for available and brown for prototype, with a popup per project.
• Viewport: the box-drop scene as spinning wire cubes, drawn into an off-screen buffer that the window blits, so it stays inside its tile.
• Palette: the 16 VGA colours. Scene: the box-drop entities with a live jiffies counter.
• Tile re-flows, Close closes the most recently opened app, Quit kills every app and restores the terminal.

Keys inside TempleOS#

Arrow keys move, Space presses a button (Enter is right-click), Shift-Esc closes a popup. A new app takes keyboard focus; click the bar to give it back, then use the arrow keys and Space.

Run it#

1. scripts/boot-vm.sh /path/to/TempleOS.ISO (ISO from templeos.org, 17,350,656 bytes; needs qemu-system-x86_64 and nc).
2. scripts/send-to-vm.sh (about a minute).

Things learned the hard way#

• Only Core0 tasks get a window, and a bare Spawn task has no document or key input. Apps run in User terminals instead, with the command typed in by XTalk.
• Functions defined in one terminal are private to it, so the library is loaded with AdamFile to make them global.
• The compiler reads one token ahead, so AdamFile(...); KosmosShell; fails: the second name is looked up before the first line has run. The loader types the call with XTalk.
• A dollar sign or apostrophe in a comment is still parsed as a DolDoc command or a character constant.
• DCFill on a window alias fills the whole screen. Draw into your own DCNew buffer and blit it from Fs->draw_it.
• The QEMU mouse is relative and scales by about 0.48, so mouse tests slam to the corner first. Mouse clicks on bar buttons worked in some runs and missed in others; the keyboard path is the verified one.
• The ISO9660 route for getting files in failed (ISOInit exception); the serial route works.

Not done#

• Runs on the live CD, so nothing is saved across reboots.
• The bar does not refresh when an app is closed by other means (it redraws on the next click), and Close only closes the most recent app.
• The Viewport is a wireframe, not the engine.