gui_toolkit: releases

gui_toolkit 0.96.0

2026-11-07T00:00:00Z

Added

ui.press_hand: the press held on one box goes on on another, with what it keeps (ui.press_data), for a gesture whose item is built in another place while it lasts: a tab dragged out of a list into a grid of pinned ones, whose boxes have other parents, stays one drag.

gui_toolkit 0.95.0

2026-11-07T00:00:00Z

Added

Contrast: ui.luminance and ui.contrast (WCAG's ratio), ui.to_oklch / ui.from_oklch for linear colours, and ui.readable(fg, ground, ratio): the colour moved along its OKLCH lightness, its hue and chroma kept, only as far as it must to read on the ground (lighter on a dark one, darker on a light one).
The system's light / dark, on Windows too, and when it changes: platform.dark_mode_preferred() reads Windows' app mode (AppsUseLightTheme) as it read the portal and GTK on Linux; platform.color_scheme_serial() moves when the choice may have changed (WM_SETTINGCHANGE "ImmersiveColorSet", the portal's SettingChanged): an app that follows the system compares one integer a frame.

gui_toolkit 0.94.0

2026-11-07T00:00:00Z

Changed

Selected text reads on its selection: the selected part of a selectable box's text (labels, paragraphs, rich paragraphs) is painted again over the selection in the theme's new "selection text" colour (by default the text's). A faint text, a dimmed run, was lost on the selection's colour.

gui_toolkit 0.93.0

2026-11-07T00:00:00Z

Changed

The wheel scrolls as the system says: a notch moves platform.wheel_lines() lines (Windows' setting, lines per notch, characters across; three on Linux), each ui.WHEEL_LINE_PX (100/3 logical px, a browser's line) at the window's scale, in whole pixels; where the system says a page, a page less a line. Every view scrolls by ui.wheel_step(box, axis), text fields too. Before, a notch was 4 em of the box's font whatever the setting.

Fixed

A tab is drawn as space: font.TAB_SPACES (4) spaces wide, the same wherever it is (measured as shown), with a space's glyph. Fonts have no glyph for it: it was drawn as a missing one (a box) in code and in tools' output.

gui_toolkit 0.92.0

2026-11-07T00:00:00Z

Added

host.host_adopt, hooks still and after_frame, Host.times: a window and a renderer an application made in its own order of start become a host; a window whose picture would not change is not built; what a program does between two frames goes after the picture; the last picture's draw and present times.

Removed

ui.Reorder and ui.reorder_frame are gone: the drag of a reordered list is kept on the press of the item's box (ui.press_data) and ends with it (the button went up, the box went, the user left the window). The procedures take the item's box key in place of a ^Reorder and an id: reorder_begin(item, moved, threshold, press, slot), reorder_dragging(item), reorder_item_pos(item, slot, pointer, lo, hi, rate) (its animation keyed by the item's box too). Lists whose items share ids drag apart, the box's key being its list's.
ui.Dock.held is gone: ui.dock_held(&d) asks the press whether the left button holds one of the dock's controls (a tab or a floating panel's title, a handle, a floating panel's corner). It keeps nothing, so it ends with the press (the release, the box held going, the user leaving the window) and says the same at any time of the frame. Write ui.dock_held(&app.dock) where app.dock.held was read.

gui_toolkit 0.91.0

2026-11-07T00:00:00Z

Added

ui.lazy_pin, ui.lazy_pinned: the view stays on an item, a given distance into it, placed after each layout whatever grows around it; what the last layout found of it says when it has settled.
ui.press_data: what a gesture keeps lives on its press: the zero T when the press began, the same while it lasts, gone when it ends by whatever way (release, its box gone, the user leaving the window). A press of the same box again, even in one batch of input, starts from zero.
ui.window_clipboard_get, ui.window_clipboard_set: Build_Params' clipboard procedures for the system's clipboard of the build's window, so a program no longer needs a global to reach its window.
platform.events_waiting: whether a window has something for its next poll_events, without waiting. A loop of several windows asks each before it sleeps, because the poll of one window of the thread takes the others' messages.
host: a window as an object, above ui and render. host_open, host_frame (pace, input, resize, builds, picture, present), host_close, and hosts_wait / hosts_due / hosts_frame for several windows on one renderer. Hooks cover what a rich application's frame does of its own: params, input, builds (several in a frame: host_build), hold (no picture this frame), after_build, before_input, dragging, rest_frame. It keeps the orders that matter: input is read with the renderer given back, a step of a resize is that window's alone, buffers keep the monitor's size, and only the first window is paced. examples/hello and examples/todo use it; the way by hand is unchanged.
render.surface_scope: surface_use until the end of the calling scope, so a frame on a second window cannot forget to go back.
ui.view_limit, ui.view_reveal, ui.view_reveal_offset, ui.view_jump, ui.view_shift: the verbs of a scroll box's view, for code that wrote view_off, view_target and view_anim by hand. view_reveal says whether the target moved, so a caller decides on scrollbar_reveal itself; view_shift keeps a glide under way and leaves a target at the top there.

Changed

A lazy column looks each item up once per build, in one map: an item's height is noted after the layout that placed it.
Splitters, dialog grips, floating panel corners, range sliders: what their drag starts from is kept on the press (ui.press_data), not in the State's one drag payload. ui.drag_store and ui.drag_load stay, for gestures that read an earlier press (panes).
render.Window_Target: what is one window's is now a struct of its own, included by using in Renderer and Surface, and Wgpu_Window on the WebGPU side; surface_use exchanges them whole, so a new window field needs no list. Field access is unchanged, except that Surface.gen and Surface.space_epoch are now Surface.swap_gen and Surface.swap_space, and Surface.wgpu_backing is a ^Wgpu_Window.
A row taller than its view keeps its top: ui.list, menus, reorder_offset, the focus and the accessibility reveal now follow the rule ui.vlist had, instead of showing the row's bottom.
A box's name and text: copied as they are at each build, without going through the formatter.

Fixed

WebGPU second windows: a window's frame format now goes with it through surface_use, as its offscreen target does on Direct3D 11.
Scrolling: dragging a scroll bar's thumb or stepping a long menu ends a glide under way, which could pull the view back for a frame; a ui.vlist whose rows moved during a glide no longer starts the glide over.

gui_toolkit 0.90.0

2026-11-06T00:00:00Z

Added

render.surface_init under_children: a composition surface below the window's child windows. A web view moved into a window with a composition surface stayed hidden behind it.

gui_toolkit 0.89.0

2026-11-06T00:00:00Z

Added

ui.tween: a value that reaches its target in a set time, gently at both ends, for what the eye follows from end to end.
draw.glyph_run_stroke: the outlines of a glyph run as a line of a width.
font.glyph_ink_extent, font.run_ink_spans: where the ink of a glyph or a run crosses a band, from the outlines, kept per glyph and band: the gaps of a skipping underline.

gui_toolkit 0.88.0

2026-11-06T00:00:00Z

Fixed

Text in a dialog or a popover can be selected: their panel took every press, so a plain .Selectable label in it selected nothing, showed no text cursor, and a label made .Clickable to get the press counted as a button. The panel is now .Press_Stop (new Box_Flag: clickable only so that what is under it gets no press): a press on it is a press on nothing, selectable text in it takes its own, and a selection stays on the surface it started on, whatever is built behind it.

gui_toolkit 0.87.0

2026-11-06T00:00:00Z

Added

push_clip_polygon takes several contours: a point past render.POLYGON_BREAK ends one, with no edge to the next: a clip with holes.
draw.Path: lines, quadratic and cubic Bézier curves, arcs and rounded rectangles, flattened to a tolerance, filled (path_fill, nonzero or even-odd, holes included) or stroked (path_stroke, round ends and joins, even in translucent colors), with path_contains for hit tests, path_bounds, bezier_cubic_at, bezier_quad_at and draw.bezier.
draw.line, draw.polyline: a line of any angle, with round ends and antialiased edges.

Changed

render.release_targets takes the textures to leave: a picture still on screen stays, for the program to carry over to the new generation.

gui_toolkit 0.86.0

2026-11-06T00:00:00Z

Added

platform.drag_silence_limit: for tests, how long a drag may stay silent before it is given up.
Signal.pointer_clicked: the click was the button's, so the pointer is where it says. clicked stays true for Enter, Space and a screen reader too.
platform.cancel_close: takes back a Close the app answered by staying open: is_closed no longer stays true for good.
Event.lost: a Mouse_Release made because the system took the pointer. It is no click, and a middle button lost soon after its press no longer latches autoscroll.
Event.Frame_Press: a press on the window's frame or caption (Windows). What the window was doing ends with it: a latched autoscroll waits for the next click anywhere, and a click there came to nobody.
font.atlas_end_frame: a draw context between frames holds no page (draw.end_frame calls it): a context that stopped drawing no longer keeps the atlas from reusing pages.
devtools.stop(srv, s): for a program that goes on after the server, the ui.State it served: the clients' edits, the highlight and the accessibility tree asked of it end too.
Signal.pointer_pressed: the press was the button's, so the pointer is where it says and it is held. pressed stays true for Enter, Space and a screen reader too. ui.slider and the colour pickers read it: Enter on them no longer set the value from wherever the pointer was.

Changed

ui.Reorder holds the press that drags (held) in place of active: a release and a press read in one frame end the drag, as does the box held going away. Read reorder_dragging.
Escape in a dialog goes to the dialog on top at the end of the build, and closes it at the next one: read in the frame a new dialog opens, it closed the one under it. open turns false one build later than it did.
ui.Autoscroll says where a session is in one field, phase (Autoscroll_Phase: Off, Holding, Latched), in place of active, held and latched; every end zeroes it, with the box it scrolls (box). State.auto_box and State.auto_pressed are gone.
draw.open_plane_frame: ok = false for a plane being recorded, which draws nothing (Open_Plane.mode replaces hit).
A capture of a frame WebGPU could not get (a hidden window's surface) says Failed: it stayed Pending.
A box that goes lets go of what held it: a press, the focus, a click on the way to a double one. A box of a vlist or a lazy column has only left the view: the focus waits for it there.
devtools: what a client started is its own. A screencast, a recording and the tree of DOM have one client: another's Page.startScreencast, its Toolkit.*Recording, DOM.undo / redo / requestChildNodes and the like are refused, and its stop and acks change nothing. A recording ends with its client, typed text included; a highlight goes with its client; what a client held down, buttons and keys, goes up when it goes.
instance.Owner_State: an Owner says where it is (None, Claimed, Serving, Closing) in Owner.state, which replaces Owner.closing. A second owner_start answers false and opens nothing, a file descriptor 0 is one like any other, and a window that could not be destroyed no longer points at its Owner.
config layers: Entry.locked is gone, is_locked reads the layer, and an observer sees a policy value locked. .Default no longer goes over a layer, reset under a policy changes nothing, load_file wants the tag of the layer it reads (POLICY_MAGIC for .Policy), register answers how many waiting values it refused, a user's value that its definition refuses stays in the profile, and dirty counts a change under a higher layer and no longer a file just read. restore survives an observer that registers.
A dialog gives the focus back: what had the focus when ui.modal opened has it again when it closes, unless something else took it meanwhile.

Removed

render.Pacer.latency: Present_State.max_latency says what the swap chain has, a new one included.

Fixed

A press on a row of an open menu leaves the keyboard focus where it was: choosing an item of a field's context menu with the mouse took the focus from the field.
testkit/session: advance in a build ends the test (it hung to the test's limit), draw_context on an attached session says so, Session.damage is the next frame's only, and the guard against two tests at once is atomic.
ui.a11y_tree is empty when no tree was made (it answered with the last one), and an active descendant not made in this build is not named.
Title bar regions are forgotten with no caption or window too: buttons no build makes any more stayed in chrome_regions.
A box of the last build looked up during a build has no text, name, accessibility or custom data: they pointed into memory the build had freed.
ui.theme_destroy leaves an empty theme: a palette applied after it appended to freed memory, a second destroy freed it twice.
ui.color_picker: the text left by the user is written as the picker writes it: a spelling of theirs (#F00) or what is no colour stayed. Color_Pick.shown is gone.
Find in page: a sweep's wait is a timed wake, not a frame at each refresh, and a sweep during a glide reports the place in the content (the scroll had moved after the layout). Its clock is the build's.
Toasts ask for frames only while they fade, and a wake between; ui.set_toast_area lasts one build, whether toasts_build ran or not.
Docks: two requests in one frame are both done, and the stack's menu of a closed panel closes.
vlist: vlist_scroll_to on a list with no box yet is kept for its first build, the wheel ends the wait for a row with the reveal, and a row of no height is not waited for over 600 builds.
list and vlist: rows gone from under the active row say changed; no row is nothing to reveal (reveal stayed armed); a row selected before the first build comes into view with no other frame asked for.
ui.text_edit_caret_rect says false once the editor is built no more.
text_edit: the column of Up and Down ends with every other move and edit (undo, redo, select all, cut, paste, Ctrl+Backspace, a double click kept it).
The caret of a line_edit is solid after an arrow key, as a text_edit's is: it could stay in the off half of its blink.
Undo in line_edit and text_edit: a move of the caret ends a step (type, arrow, type was one), and a field's steps go by the build's clock, as a text area's do.
Menus: a press of a side button outside closes them; a Right or Enter on a submenu that turned disabled opens nothing later; a menu opened from the keyboard selects its first item once, so a pointer on a disabled row leaves nothing selected; a menu opened from inside a menu's block opens when the block ends, its rows not mixed with the old one's.
ui.stepper: held with the pointer off its button it waits, as a scroll bar's arrow does.
A press with no pointer (Enter, Space, a screen reader) no longer takes the place of a drag going on (splitter, pane_split, the edges of modal_sized), sets a range_slider from the pointer, or moves the caret of a line_edit or a text_edit to it.
ui.pane_split: a strip pulled out and pushed back under the snap stays folded when let go, and a screen reader's value on a folded pane says toggled. What a press was on is one state (Pane_Press).
ui.modal_sized: a press on an edge that does not move chooses no size (the size a small window clamped it to stayed for good), and a double click on an edge stays at the preferred size while the button is held.
platform on Windows: a surrogate pairs only with the unit right after it, a pointer whose end the system no longer describes still ends, a resize made of inner frames has its burst.
Clipboard on Linux: a selection another program cleared is not read back, X11 asks the server who owns what it took, a late answer is not the next read's, a paste leaves no property, an INCR reader that left is given up, XdndSelection is let go, a large drag goes by INCR, a reader that closes its pipe no longer ends the process on Wayland. Windows: a real window's clipboard_changed reads the system's clipboard with an offscreen window open.
platform on Linux: a seat that loses its pointer or keyboard and gets it back works again, a scale change of the output or of Xft.dpi reaches the windows, the display is read again after a change of the output.
platform on Linux: a window has one state (Show_State), read back from the server: nothing shown is not visible, a state asked before the map reaches the window manager. set_placement restores a maximized window on every backend and applies at once on a shown Windows window, an offscreen set_fullscreen(false) leaves another state alone, toggle_maximize leaves full screen on Windows.
Accessibility on Linux: the bridge is read by the window's loop, it keeps the whole tree an update changes (platform.a11y_tree_merge), a11y_state is Off until a reader runs (org.a11y.Status), a bus that refuses is asked once.
File dialogs on Linux: a bus without a portal falls back to zenity and kdialog, the portal's answer cannot be missed, its filter is the user's choice, a lost bus is Failed and not Cancelled. idle_inhibit ends with its window.
Tray on Linux: each icon has its own object, a failed create leaves nothing exported, a panel that restarts gets the icons again (Recreated), a menu that changes is told (LayoutUpdated), a notification has a default action, so Notify_Click can come, and one that closed is not replaced by the next. Windows: an icon a restarting shell refused is added at its next change.
Drag and drop on Linux: a drag says where it is (Drag_Phase). X11: only the button that began it ends it, Escape gives it up. Both: the limit is one of silence, a target that took a drop has five seconds, the target hears what the source allows and a Move is told, a source that dies ends its drag, a target disabled under a drag says Drop_Leave, no event of kind None. A drag script is used up however drag_start ends. drop_inject of anything but Drop_Enter needs a drag over the window.
platform on Linux: set_cursor to the cursor the window had takes a custom cursor off the screen, releasing the shown custom cursor shows the window's own, Wayland sends a cursor only for the window under the pointer, set_cursor_custom's scale is used.
platform: a release comes once and only of a press made here, on every backend; a pointer taken with a button held makes its release on Wayland and when an X11 window is unmapped; X11 says no Mouse_Leave under a press, as a capture on Windows; a key held when the focus goes makes its Key_Release. Activate comes once for a change, and a window is neither focused nor active until the system says so.
platform.poll_events: the batch stays whole while the app reads it. What runs from an event may pump the system (a paste on X11, drag_start), and w.events may then move.
platform: wait_event sees all that ends it. On Linux the session bus and the accessibility bus (a tray click answered at once), injected events; on Wayland and Windows a repaint asked for; on Windows the events not handed out; after input_pending, what it kept.
platform on Linux: a closed window's last notices go to nobody (the X11 window that polled read as minimized), a window closed under a drag or an input method leaves nothing that points at it, a compositor without xdg-shell fails every open_window, and a server that goes away closes its windows (Display_Link) instead of leaving a loop that never hears of it.
platform on X11: typed text follows Shift, AltGr, Caps Lock and the layout (a key is read with the modifiers and the group of its event), a change of keymap is followed, a held key says repeat. On X11 and Wayland a key keeps its name whatever it types: Shift+1 is N1, Shift+Tab is Tab, the keypad without Num Lock is Home, Left...
Focus keys: an arrow and a Tab read in one frame both move the focus, and ui.focus_step says its direction (ui.tab_direction): a rich paragraph entered backward that way starts at its last link.
Signal.mods follows Key_Release and Mouse_Release: a modifier let go during a drag is no longer held.
ui.rich_paragraph: Enter and Space choose the link that has the focus wherever the pointer is (they took the link under it, or nothing over plain text), and a screen reader's focus on a link of a paragraph without the focus stays.
The build lifecycle: ui.building() stays true to the last line of end_build; end_build ends the build that is open, whatever use selected since, and asserts that there is one; ui.destroy in the middle of a build leaves none open on the thread. end_build also asserts the list and menu scopes.
Selected text is one state (Sel_Phase): no drag goes on with its selection gone (the text cursor and the frames stayed), select_box ends a drag, and a press on a button between two presses on a text breaks their double click.
ui.next and ui.a11y before what builds nothing (a closed modal, modal_sized, ctx_menu or menu_nested, a skipped lazy_item) no longer land on the next box.
An open menu no longer gets the keys something else took first (Ctrl+zoom, autoscroll's Escape).
Autoscroll: a move of the window ends a session, as its documentation said. A move read with the release counts against a tap. What ends a session no longer ends the frame's input: a middle press read with it starts the next one, and the Escape it took does not reach an open menu.
The window the user leaves (Event.Activate, Build_Params.inactive): an open menu closes, a held button ends with no click, the modifiers are forgotten, a selection stops following the pointer, autoscroll ends. A dock drag cut that way drops nothing.
A box that goes takes what held it: at the end of a build a press, the focus, the first click of a double click and the link of a rich paragraph let go of a box the build did not make. A key that comes back later is another box; a focus given ahead of its box stands. splitter and pane_split say finished when their box is back.
ui.set_post_wake: the app's wake is called with a nil user too, and a nil wake goes back to the window's. Of two windows of a State, posts wake the one that stays when the other is destroyed. A post on a State that is gone is refused.
ui.post_configure runs every call that waits, not a build's budget of them (the rest were lost), and a closed queue stays closed.
draw.offscreen_end: closes the layers left open in the target (it answered 0 and left the target open).
font: the emoji font comes back on the next emoji when whoever shared its id unloaded it.
font: a word being shaped while the word cache is cleared is shaped again, and no thread keeps the width of a word cleared under it.
font: a glyph the COLR interpreter was drawing when the settings changed is drawn again with them, and its outlines follow a new provider or tolerance.
font: glyph_outline and slug_glyphs answer on a state never started (they read a nil backend). Text_Backend.face_close, which nothing called, is gone.
draw.destroy: in the middle of a recording it no longer leaks the lists of the frame.
draw: a layer or plane that replays a picture lacking a pending color glyph is not kept: the glyph comes when it is ready.
Frame statistics on WebGPU: frame_end(vsync = false) on a Fifo surface counts the vblank it waits for, a reconfigured surface starts its run over, and vblank_grid says unknown once the compositor stops answering (Direct3D 11 too). gpu_ms starts over with a new device.
draw: a mask layer with no target of its own draws nothing (its drawing landed in the content); Open_Layer says what it is and what a mask draws in with Layer_Kind and Mask_Draw.
draw: a layer or a plane owns what is pushed in it: pops stop at where it started and at the root (they panicked there), what is left pushed ends with it, and layers and planes left open inside one another end in the order they were opened. A recording cannot close a plane of the frame.
draw: a second end_frame does nothing (it drew the frame twice).
render.canvas_read_ready and canvas_read_finish on a read begun before a device loss: ready at once, and the finish says it failed. They used the old device's objects on the new context.
2D canvas layers nest. A filter pass inside an open layer leaves it open, what is drawn into a layer that could not be made or was freed goes nowhere instead of onto the canvas, and a layer replaced by a filter pass gives its texture back to the pool. canvas_set_opaque on a source texture no longer outlives it.
A texture a recovery could not make again: Texture_Kind.Failed, it draws nothing, texture_size says {0, 0} and destroy_texture frees its slot. A frame crashed on one (Direct3D 11), and its slot was lost.
render.set_fixed_surface survives a device loss: the chain made again had the window's size, and a window larger than it was clipped. A translucent window that fell back to opaque during a recovery tries DirectComposition again at the next one.
render.readback_poll says Failed for a read-back whose frame did not run, which stayed Pending for good, and for an id of another renderer. A renderer destroyed takes its read-backs with it.
font: a system fallback that goes character by character (fontconfig) no longer cuts a sequence: joiners, selectors and what follows a ZWJ stay with their base.
font: the Slug store follows what its glyphs depend on: color_glyphs and color_engine reach the glyphs of color faces, a new provider is asked for what had no curves, no room is not kept, and keys hold the slot of a face, so what a face leaves goes with it at any generation.
Partial redraw: a frame that stopped halfway (Direct3D 11), that had no surface texture (WebGPU) or whose region could not be cleared leaves nothing the next region starts from: the next frame is whole. Their rectangles were lost, or composed onto a blank target.
A window that cannot be remade (Direct3D 11, WebGPU) counts as a device lost: the next frame_begin tries again, where it drew into nothing and the next clear crashed. A swap chain that ResizeBuffers finds gone is a loss too, and a size asked while there is no swap chain is kept.
font: a page reused uploads whole to a context that had it: the old bitmaps no longer stay in its texture between the new ones.
render.surface_destroy of the Surface in use gives the renderer back its own window first: it tore that window down.
Second windows on WebGPU: a window set aside is made again after a recovery and follows set_blend_space, as on Direct3D 11. Its capture, its clear and its first frame are its own, and surface_destroy frees its frame statistics.
font: a color glyph drawn on the color thread whose COLR layers cannot be read shows its outline, as on the drawing thread (it was kept as a bitmap at page 0, out of range when no page exists).
A device lost on WebGPU: it is noticed (wgpu-native reports every loss with the reason Destroyed, which was taken for the renderer's own release), offscreen too. A recovery makes the new device first: with none to be had the old one stays and frames draw nothing, where they ended the process on a nil device. Calls that end the process on a device gone (QueueSubmit, DevicePoll, SurfaceConfigure, SurfaceGetCurrentTexture) wait for the recovery.
font: the id of a font just unloaded, or of a cascade, no longer leaves blank glyphs for the next face in its slot (Font.dead and State.generation are gone: an unloaded slot is Font_Kind.None).
AT-SPI on Linux: the bridge's connection is dispatched once a frame, so what a client asks of the exported object is answered and a lost bus is seen.
native/a11y: an update that is refused or finds no assistive technology leaves the deferred focus as it was, and one that would give a subtree a second graft node is refused instead of ending the adapter.
arena.Pool: a slot whose generations are spent is retired instead of wrapping, so a handle never comes back to life, even after 2^32 reuses.
devtools input and recordings: two Toolkit.click of one batch are two clicks; a drag cut by Toolkit.stopRecording gets its up, a second button no longer breaks a recorded drag, and a right drag replays as one (down and up of tools/cdp.mjs take --button right). CSS.setStyleTexts does all of its edits or none, a ; in a string or a comment no longer ends a declaration, and a frame of a screencast that ended no longer touches the one that took its place.
devtools connections: a connection that sends no request is closed after 5 seconds, an upgrade needs Upgrade: websocket and version 13, and a frame RFC 6455 does not allow ends the connection instead of being glued to the message under way.
instance on Linux: acquire and send never block past their timeout, with a large message or a full backlog, and an owner that wakes after a sender gave up no longer handles its message as well.
config.save_user goes through fsx.write_atomic, flushed: a save that fails never removes the profile, and leaves no temporary file.
fsx: write_atomic writes through a temporary file of its own, <path>.<pid>.<thread>.tmp, so two writers can no longer tear a file; replace with durable answers false when the directory could not be synced; read_all no longer returns a replaced file cut to the old size.
dbus: connecting cannot hang the window's thread. connect, the SASL answer and Hello each have a limit of 5 seconds, and a signal no longer fails the authentication.
dbus: a lost bus closes its socket. conn_fd answers -1 from then on, so the window loop no longer spins on a socket at EOF; nothing more is read after a stream that cannot be parsed, a failed send runs the call_async handlers that wait at the next dispatch, and platform falls back as with no bus. A handler of an expired call that calls no longer panics, serial 0 is never used, and conn_close from a handler asserts. Call_Status.Unsupported, never produced, is gone.
Read-backs on WebGPU: a buffer is released outside the table's lock. Releasing one still being mapped may call its callback, which takes that lock.
flate: an inflater that failed stays failed (inflate_finish said Truncated, and a later push went on from where it stopped), and nothing is written after deflate_finish (it wrote past the end of the stream).
ui.find: a sweep left waiting when its page went away kept needs_frame true for good, and the loop never slept.
ui.line_edit, ui.text_edit: the word a double click took collapsed to the pointer at the first frame made with the button down. The drag now goes on by words, as selectable text does.
draw: an offscreen target left open is dropped at the end of the frame (it was composited, left its transform on the stack and cut the filters of the layers around it), and a plane left open in a recording ends with the recording (it took the frame's stacks down at end_frame).
Dock drags that lost what they held: closing a floating panel while it was dragged ended in a bounds check (docking.odin), a panel closed while its tab was held came back at the drop, a drag whose button went up while the dock was not built dropped when the dock came back, and Enter on a held tab restarted the drag.
Dialogs on dialogs: with two open, the one underneath took the focus away at every frame, so a field of the top one could not keep the keyboard, and Tab went through both. Each dialog now knows where it stands among those of the last build: the top one has the keyboard, the others wait.
D-Bus: r_skip never returned from a message cut short inside a struct or a dict entry, or from an array of a type that takes no bytes; it ran on the window's thread.
DevTools: Page.startScreencast on a window served with no ui.State is refused. It woke the window for good, and an ack dereferenced the missing state.

gui_toolkit 0.85.0

2026-11-06T00:00:00Z

Added

ui.toast_action: a toast that a click acts on, and dismisses, for one that says what can be done.

Fixed

The corners of a floating panel: its panels, drawn after its frame and square, covered the frame's round corners, whose border stopped short of them. They are clipped to the frame now, and its border goes over them.

gui_toolkit 0.84.0

2026-11-05T00:00:00Z

Added

Text per colour stripe: font.Settings.subpixel_text (.Rgb, .Bgr) gives text a coverage per stripe of the screen's pixels, sharper at few pixels per letter, on Direct3D 11 with the atlas (DirectWrite) and on WebGPU with Slug (three samples a third of a pixel apart). Blended per channel in the frame's own target; in a layer, or turned, the same text is grey. font.system_subpixel_text says what the system does, render.text_subpixel_supported what the renderer can.
The site says what it is when it is shared: a card, Open Graph and Twitter tags on every page, an Atom feed of the versions, a sitemap and a manifest (tools/site_meta.mjs, at deployment).

Fixed

Read-backs from several threads: the process's table of read-backs was allocated with the allocator of whoever wrote in it first, and freed by whoever emptied it, through an allocator that could be gone. It is on the process's heap.

gui_toolkit 0.83.0

2026-11-05T00:00:00Z

Added

The side buttons of the mouse: Mouse_Button.Back and .Forward on Windows, X11 and Wayland, ui.mouse_pressed(.Back), and back and forward over the DevTools protocol.

gui_toolkit 0.82.0

2026-11-05T00:00:00Z

Changed

Middle-click autoscroll goes five times faster by default: up to 15000 px/s, reached 300 px from the anchor, the speed doubling every 60 px (DEFAULT_AUTOSCROLL): the curve Wren settled on. It was 2800 px/s at 420 px.
A target_hz above the screen's rate is made: 120 on a 60 Hz screen is up to 120 frames a second while something moves (none at rest), each on its slot, none waiting for the screen, shown at once (Cadence_Plan.above): it stayed at the screen's rate. The screen shows the newest: not smoother, but each refresh has fresher input.

gui_toolkit 0.81.0

2026-11-05T00:00:00Z

Added

ui.modal_sized: a dialog of a size of its own, centered and always within the window: it opens at what it prefers, the person resizes it by its edges and corners (the opposite side follows, it stays centered), a double click goes back; the size is the application's to keep. ui.modal stays in the window too: narrower if it must, higher when what is in it would pass the bottom.

gui_toolkit 0.80.0

2026-11-05T00:00:00Z

Added

The output of frames is the application's to choose: Pacer.choices (a ceiling, a rate; read at the next frame, render.pace_frame planned with none), and Cadence.uncapped: no slot, no wait for the screen, every frame shown at once, for a diagnostic or a benchmark. A window at rest stays at rest.

Changed

platform.wait_slot: render.pace_frame no longer sleeps through a frame's slot: input is taken as it arrives (time-stamped, kept for the next poll_events), a key or a button ends the wait, a pointer that moves and the wheel do not. wait_handle has until_press. An offscreen window does not wait.

gui_toolkit 0.79.0

2026-11-05T00:00:00Z

Added

ui.find_sweep, ui.find_all, ui.find_pending, ui.find_refresh: a find in page over a lazy column reads everything once for a needle (when it rests 80 ms, and again if what is built no longer answers), and stays lazy between: lazy_begin(all = find_sweep()). In opencode native, a frame while finding 40 -> 1.7 ms on a conversation of 150 answers.

Changed

Text cut with an ellipsis: where it is cut is kept (by text, font, size and width): it was measured rune by rune at every frame, through the shaper. A frame at rest in opencode native 1.65 -> 1.10 ms.

Fixed

render.pace_frame waits for the frame's slot, after the swap chain and only what is left of it: Frame_Decision.wait_ns was worked out and not made, so nothing capped the frames of a screen that does not hold the app back. platform.precise_sleep: a wait under the system's tick.

gui_toolkit 0.78.0

2026-11-04T00:00:00Z

Added

Dock_Options.strip_last: boxes after a stack's fold and menu buttons, the strip's last control (a window's close button stays at the far right; strip_end comes before them).
ui.field_num_step: the number at the caret of a focused field stepped as browsers' style editors step it: Up / Down 1, Page Up / Page Down 10, Shift 10, Alt 0.1, Ctrl 100, and the wheel over the field with the same modifiers; its unit and the text around it stay (margin: 10px 5px, rgba(10, 20, 30, 0.5), calc(100% - 12px)), a number inside a word or a hex colour is none, the number stepped is selected and the step is an edit of the field's history. ui.num_step_text and ui.num_step_delta do it on a string and a key press.
ui.color_picker: a colour picker for a ui.Color_Pick the app owns (color_pick_set, color_pick_rgba, color_pick_text, color_pick_destroy; color_picker_width): a saturation / value square, a hue bar and an opacity bar beside the colour it was opened with (a click takes it back) and the new one, a switch of the text's format (hex, rgb, hsl, oklch) and the colour as text, applied as it is typed. Every part is a Tab stop, moved by the arrows (Shift: a tenth; the hue by degrees), and screen readers see sliders, a radio group and a field. No eyedropper: the platform layer reads no pixel of the screen.
ui.color_parse / ui.color_text: hex, rgb() / rgba(), hsl() / hsla() and oklch() read and written, in the style they were written in (Color_Style: the format, the legacy comma syntax or the short hex); srgb_to_hsv, hsv_to_srgb, srgb_to_hsl, hsl_to_srgb, srgb_to_oklch, oklch_to_srgb.
ui.alpha_picker, ui.checker_draw; hue_picker takes horizontal; sat_val_picker, hue_picker and alpha_picker take the keyboard and tell screen readers their values.

gui_toolkit 0.77.0

2026-11-04T00:00:00Z

Fixed

A folded pane's strip in the theme, a fold button on the stacks that fold, tooltips the size of their text: the strip of a folded side (pane_split, a dock's folded split) painted nothing at rest and the palette's raw hover colour (opaque white on a dark theme) under the pointer; it now has the theme's pane_strip background (by default the bars' surface) and the theme's hover_fill over it, and its chevron is larger (PANE_CHEVRON_EM 1.4, also pane_toggle's). A dock's stacks on a side that folds have a chevron button at the end of their strip, as large as the menu's button (pane_toggle, which now takes the size next gives it; a Tab stop, Enter folds); a strip's tabs are in the room its end's buttons leave, so tabs too many for a narrow stack are cut and the fold and menu buttons stay in view (they were pushed out of the strip). A tooltip's content inherited the app's style, so under a style that fills it was as large as the window; a size relative to the window is now the content's own in it, ui.tooltip_text(text) is as wide as its text up to TOOLTIP_MAX_WIDTH_EM and wraps past it, and tooltip goes above the pointer when it does not fit below (TOOLTIP_ABOVE_EM); its first frame measures it unseen and asks for the next one, which places it (it was placed by the size of 10 x 3 em it was taken to have, and stayed past the window's edge when nothing else made a frame). Tests docking a_folded_strip_takes_the_theme_colours, the_fold_button_folds_and_the_strip_brings_it_back, the_end_buttons_stay_in_view_past_too_many_tabs, a_tooltip_over_a_tall_strip_fits_its_text; ui_robust tooltip_places (above the pointer at the bottom).

gui_toolkit 0.76.0

2026-11-04T00:00:00Z

Added

ui.menu_at(p) and ui.wheel_consumed(): the wheel over an open menu is the menu's: menu_at says whether a point is on a level of the open menu (a submenu, a nested menu, a drop-down's list) as the last build laid it out, so an app that routes the wheel to its own content before it builds the interface (a browser's page) gives it nothing there; wheel_consumed says whether this build's wheel went to the interface (a box that scrolls under the pointer, or a menu's level, one that fits included). A menu taller than the window scrolls under the wheel, one that fits takes it and does not move, down and across; the scroller under either gets nothing (test keyboard menu_takes_the_wheel_over_it).

gui_toolkit 0.75.0

2026-11-04T00:00:00Z

Changed

Slug glyph data built in half the time: slug_build sorts the curves of an axis once (one u64 key each) and puts each curve in the bands it spans, found from its bounds against the bands' own; it sorted the curves of every band and tested every curve against every band of each of the ten band counts it tries. The same data (test slug bands_are_their_definition); 400 glyphs of a face, best of 5: Segoe UI 5.5 -> 2.8 ms, Times New Roman 8.3 -> 3.9 ms, Nirmala UI 10.0 -> 4.6 ms.

gui_toolkit 0.74.0

2026-11-04T00:00:00Z

Changed

font.color_prepare, textures zeroed on the GPU: font.color_prepare makes what color glyphs are drawn with (Direct2D on a WARP device, about 20 ms) for an application to call on a thread of its own while it starts; the first color glyph a frame looked up made it on the drawing thread. Textures are made render targets too and zeroed by a clear on the GPU (ClearRenderTargetView) where they were zeroed by uploads of zeros: a 2048 x 2048 glyph atlas page 6 ms (R8) and 3.5 ms (RGBA) of the CPU before, its first frame's.

gui_toolkit 0.73.0

2026-11-03T00:00:00Z

Fixed

The ASCII case helpers are package ascii (ascii/ascii.odin: ascii.lower, upper, lower_byte / upper_byte, equal_fold, has_prefix_fold, contains_fold), no longer base's ascii_*: a package named base, which font, devtools, platform and config now import, clashed with an app's own package of that name (Odin wants one name per package in a program).

gui_toolkit 0.72.0

2026-11-03T00:00:00Z

Fixed

ASCII case for names and protocols: strings.to_lower, to_upper and equal_fold of Odin dev-2026-11 fold by Unicode (the Kelvin sign U+212A is k to them, the long s U+017F s), where names and protocols want ASCII. New in base (base/text.odin): ascii_lower, ascii_upper, ascii_lower_byte / ascii_upper_byte, ascii_equal_fold, ascii_has_prefix_fold, ascii_contains_fold. Switched to them: the DevTools server's header names and Host (Ho\u017Ft: is no Host, localho\u017Ft no localhost), CSS colour keywords, nodeName, the accessibility roles and actions; font family names as cache keys (Windows, Linux, macOS) and fontconfig's / Core Text's answer checked against the family asked for (DejaVu San\u017F no longer loads DejaVu Sans); preference booleans; the GTK theme name, file extensions for MIME types on Linux; the changelog tool's type and slugs, tk's checksums and emoji version line, run_tests' groups, the examples' option names. Unicode stays for user text (find in page, fuzzy matching, type-ahead, the settings' and DevTools' searches, the test session's text lookups), display text and Windows paths. Lint tests/unicode_case (a step of run_tests): a call of strings.to_lower / to_upper / equal_fold or unicode.to_lower / to_upper in the toolkit's sources fails unless tools/unicode_case_allowed.txt lists its line with why; an entry that matches no line fails too.

gui_toolkit 0.71.0

2026-11-03T00:00:00Z

Added

Docking (ui/dock_model.odin, ui/docking.odin, docs/docking.md): the app's panels in stacks of tabs the user rearranges. The layout is the app's ui.Dock, flat data: a tree of nodes in one #soa array (leaves: a stack of panels and the one shown; splits: an axis, a ratio, the second side folded), floating roots at a place of their own, the panels (the app's u32 ids) in tab order; dock_add, dock_move (into a stack at a tab, at a side of one, at an edge of the space, floating), dock_move_node, dock_redock, dock_close, dock_activate, dock_set_split, dock_layout, dock_target_at; one line of text (dock_format / dock_parse: unknown names dropped with the stacks they leave empty, the panels it does not name placed by the app, any other text refused with the dock left as it was). dock_begin / dock_panel / dock_end build it: a tab dragged out shows the drop targets (five squares over the stack under the pointer, four at the edges of the space, the strips between their tabs) and a translucent preview of where it lands; let go elsewhere it floats (an overlay of the window with a frame and a shadow, moved by its strip with the drop targets, resized by its corner, docked back by a double click); Escape cancels; the handles are pane_split's (minimum sizes, fold); close buttons, a middle click; the stack's menu reaches every drop target from the keyboard; the arrows along a strip, Ctrl+Shift+arrows move a tab, Ctrl+Tab goes through a stack; roles tab list, tab (controls its panel), tab panel, separator. Theme entries dock_preview and dock_marker. Example examples/docking; tests tests/docking (the model and the text; the drags, the keyboard and the menu through the test session).

gui_toolkit 0.70.0

2026-11-03T00:00:00Z

Changed

ui.build_events: a copy of the last build's input, kept by the state until the next build (it was the caller's slice, valid until its next poll).
Built with Odin dev-2026-11 (pinned by SHA-256 in the CI, docs/getting-started.md): core:image's pixels are a [dynamic]u8, nothing keeps a reference to a stack past its procedure (the compiler's new escape analysis: the tests' globals are cleared, ui.use keeps the caller's state on purpose), core:compress/deflate checks flate's streams in the tests and docs/flate.md compares both (flate stays for streams and deflate_runs). wgpu-native stays 29.0.1.1.

gui_toolkit 0.69.0

2026-11-03T00:00:00Z

Added

Menus taller than the window scroll: a level (menu, submenu, nested menu, dropdown list) whose content is taller than the window is as tall as the window, placed again at each frame (a window made shorter while it is open), and scrolls: the wheel, its scroll bar (a press on it is not a press outside; the rows leave it room), the keyboard's selection brought into view (Up / Down / Home / End / Page Up / Page Down, type-ahead to a hidden row, a dropdown's current value from menu_select). A menu that fits is placed as before (flipped to the other side of its anchor, else shifted to stay whole). ui.menu_item_rect(depth, idx): where an item was laid out. Tests menu_taller_than_the_window_scrolls, menu_near_the_bottom_flips_or_shifts

Changed

Menus are dense: MENU_ITEM_EM is 1.9 (was 2.2): rows of 29 px for 15 px text, as Windows 11's and Chrome's menus (times the density: 22 px at DENSITY_COMPACT, 34 px at DENSITY_MAX); the padding above the first item and below the last is 0.25 em (was 0.3), a separator's gaps 0.2 em (were 0.25); the icon cell is as tall as the row. Test menu_rows_follow_the_density

gui_toolkit 0.68.0

2026-11-03T00:00:00Z

Added

ui.pane_split, ui.pane_toggle, ui.Pane: panes the user resizes from a few em (PANE_MIN_EM) to all the room but a few em for the other side, folds (a drag under half the minimum, a double click, Enter, a chevron button) to a strip that brings them back (a click, Enter, a pull), and places at the side or below (pane_axis, pane_place_menu); the app owns a Pane per split (sizes per orientation, folded, place) and saves it through Pane_Options.on_save; pane_format / pane_parse make it a line of text; menu_move_to lists "Move to" items for a tab that may go to another strip. Keyboard (arrows, Home, End, Enter) and accessible (a separator with its value, expanded). examples/panes uses them. Tests tests/panes/pane_split_test.odin

gui_toolkit 0.67.0

2026-11-03T00:00:00Z

Added

ui.set_scrollbar_arrows: classic arrow buttons at both ends of the scroll bars of scroll boxes, off by default (the bars stay as they were): each as long as the bar is broad, taken from the track; a press scrolls a step (3 em, eased like the wheel), held it repeats after 250 ms every 50 ms while the pointer stays on it. ui.scrollbar_arrow_rects gives where they are; draw.triangle fills a triangle in one-pixel rows (the arrows' glyph). Test arrow_buttons_step_and_repeat