Skip to content

zgx 0.1.8

Choose a tag to compare

@wingleeio wingleeio released this 02 Nov 08:56
· 1069 commits to main since this release

A fix for 0.1.7, which drew every Chinese character on macOS 26 as blank space: a font face whose shapes zgx can't draw (macOS 26's PingFang keeps them only in Apple's hvgl table) is now passed by in fallback, and Chinese takes Heiti SC or TC. Rust and Luau code builds as before, but for a struct literal of zgx's WebViewOptions or WebViewState (each has a new field), each below with what to change. Every published 0.1.7 crate builds against this release. Forks published with it: zgx-cosmic-text 0.19.8 and zgx-mlua 0.12.7. Behaviours change too, each below with what to check.

Changed: what to check in an existing app

  • WebViewOptions has a new field, accelerated (zgx): a WebViewOptions written out field by field stops compiling. Migrate: end it with ..Default::default(), or set accelerated: true (the default).
  • WebViewState has a new field, full_screen (zgx): a WebViewState written out field by field stops compiling. Migrate: end it with ..Default::default(), or set full_screen: false.
  • A second mount in a test is the next launch (zgx-script): a test's apps in zgx test share a storage directory of the test's own, each saved before the next starts, so a second mount() finds what the first kept (ui.persist, folders kept with ui.open_folder { remember }), as a relaunch would. Each test starts with nothing kept. A headless app's ui.persist kept state in memory only.
  • A web page on Linux saves no downloads (zgx-desktop's webkitgtk): a download link or an attachment is cancelled as it starts, as on macOS and Windows, where web views save nothing without a handler of the app's. WebKitGTK saved them into the user's downloads folder unasked.
  • A test names an item's window by its key (zgx-script): app:window(key) in zgx test, and TestApp::window, take the key of an item of ui.windows (its id field, or key(item)), whose window's own id a test can't know. A ui.window's id still names it, and a key two lists share fails, saying so.

Added

  • Clear coats in 3D scenes (zgx-3d): World::set_clearcoat(id, Some(Clearcoat::new(1.).roughness(0.1))) lacquers a mesh, as car paint, varnish or a glaze: a thin coat of glass reflects the lights and surroundings over it, smooth or rough, and what is under it (light through glass included) shows the less the more the coat reflects. glTF models bring theirs: KHR_materials_clearcoat's factor and roughness, and its textures (Map::Clearcoat, Map::ClearcoatRoughness, Map::ClearcoatNormal: how much coat, how rough, which way it faces, the last its own and not the surface's). A mesh with one draws with a pipeline of its own; a world with none binds nothing new.
  • Container queries (zgx, zgx-script): container = true on a box and queries = { { min_width = 900, style = { … } } } on what's inside give styles that follow the box's content size, as CSS's @container rules, in the frame layout changes it and without running the script; a resize that crosses no bound restyles nothing. As in CSS, a container's content doesn't size its width (a debug build reports one that's 0 wide). In Rust, View::container and View::when_container(Query::new().min_w(900.), …), and Scene::set_contained.
  • Targets by class in tests and inspect (zgx-script): .tool, .tool.primary and chains such as #bar >> .tool find elements by their class in zgx test, zgx inspect and MCP, as plugin targets do: one selector language.
  • Gradient masks (zgx, zgx-script): Styled::mask_gradient(Gradient) (Scene::set_mask_gradient), Luau mask_gradient and mask_radial written as gradient and radial are: a node and what it holds show through a linear or radial gradient's alpha over its box, at whatever size it's laid out (CSS's mask-image with a gradient), for a list fading out at its bottom or a vignette. The mask's image is made from the gradient at the box's size when it's laid out, and again when the box resizes; it then draws as an image mask does.
  • Gradient text (zgx, zgx-gpu, zgx-script): Styled::text_gradient(Gradient) (Scene::set_text_gradient), Luau text_gradient and text_radial: a text's glyphs filled with a linear or radial gradient over its box (CSS's background-clip: text). The text paints into a cached layer of its own, where its glyphs draw, the gradient is kept where they cover (a source-in blend) and its selection, marks and shadows draw behind them (destination-over); selected glyphs then take the selected-text colour. The same shader as every quad, two more blend states (wgpu and Direct3D 11). Glyphs rasterize at the layer's scale, and the gradient's colours are made again only when the box resizes, so a counter re-uploads nothing but glyphs. Text without a gradient is no layer.
  • Devtools reach every window (zgx-script, zgx-run): zgx inspect windows lists the app's windows (the main one, ui.window's and ui.windows's), each with its id, size, title and popups open. Any command takes window (--window on the CLI, window on every MCP tool, zgx_windows to list) and answers for that window: an id, or an item's key in ui.windows. zgx-run registers each window it opens while devtools run (inspect::register_window), and forgets it when it closes.
  • Plugins add beside a branch's root (zgx-script): before and after at the root of a ui.show's or ui.switch's branch, or of a component, which matched nothing, are siblings in the parent's flow that come and go with the branch and read what the root provides, live. At the app's root or a window's root, which can't have siblings, they are an error in ScriptHost::contributions and to the plugin.
  • What each plugin contribution does now (zgx-script): ScriptHost::contributions() lists each ui.contribute { target } and ui.filter with its plugin, target, place, how many elements it applies at now (0 when its target matches nothing shown) and its latest error. zgx inspect contributions and the MCP tool zgx_contributions give the same, as text and JSON.
  • A plugin command's dropped shortcut says so (zgx-script): when a plugin's command declares a shortcut the app's commands (or an earlier plugin's) hold, spelled the same or not, ScriptHost::dropped_shortcuts records the key, why ("taken by the app") and the command that holds it, and ScriptHost::contributions (zgx inspect contributions) lists it as place shortcut, for the app to tell the plugin's author.
  • Where a plugin can put something and what it can read there (zgx-script): ScriptHost::elements lists the app's ids, classes and hooks grouped by each element that provides context, with a selector that reaches each group and the context names it provides and inherits. A list's repeated rows are one group with a count, private elements show nothing inside, and names the source declares that aren't showing are listed mounted: false. zgx inspect elements and the MCP tool zgx_elements give it as text and JSON.
  • A host lends a package to plugins (zgx-script): Capability::Package("ds") lends package ds to a plugin, and ScriptHost::grant_all_plugins grants a capability to every plugin, those loaded later too. zgx.json allows "package:<name>". The plugin requires @ds/… into its own VM, with module state of its own. A lent module requires only inside lent packages, never @app/…, and an error names the missing grant. What it calls is gated by the plugin's grants. An edit to the package reloads its plugins, and contributions() lists what each plugin was lent. zgx check resolves a plugin's lent packages, and zgx types adds their aliases to the plugin's .luaurc.
  • Plugins add beside a presence's content (zgx, zgx-script): what a plugin puts before or after a ui.presence's content root enters with it, and as the content leaves it stays where it lay until the exit animation ends, then goes in the same frame. A contents node whose last child lays out in its place (display_contents) now lays out flat too, with what it holds before that child kept over its place (#1275).
  • Plugins add beside a list's rows (zgx-script): ui.contribute { target, before | after | replace } and ui.filter at the root of a ui.each or ui.list row, which drew nothing, apply a row each: what is added lays out as the list's own items, keyed with its row (it follows a reorder and goes with a removal), and reads what the row's root provides, live.
  • Plugin targets by class and inside other elements (zgx-script): ui.contribute { target } and ui.filter take .class (every element with it) and descendant chains, #sidebar >> .session-row, in the selector syntax tests use. A target matching several elements contributes at each, and a chain only where its ancestors hold, including inside a list's rows. zgx lint warns of an id, hook or class in a target, a chain's parts too, that no element of the app declares; under strict types an app's classes are targets (HookTarget) and a chain is any text (HookChain).
  • Text streams into an editor where it ends (zgx, zgx-script):
    • TextEditor::apply_external(range, text) and append_external(text) take an edit made outside the editor (a model's reply, a collaborator) as set_text takes the document it makes, same undo and redo, comparing only the edit; the caret at the end follows the stream, and a selection keeps what it selected.
    • An editor bound to a long text follows the edits the text keeps (zgx::text::Text remembers its last 16), applying each where it is.
    • A \r and a \n streamed in different tokens make one line break, not two.
    • Luau's state:append(text) (and append(path, text)) adds to a long string in place, keeping the edit for a bound editor, and a string growing past 64 KiB becomes one; zgx lint flags state:set(state:get() .. token) (append-concat).
  • Text says the language it is in with lang (zgx, zgx-desktop, zgx-script): HTML's attribute, as Styled::lang, TextSpan::lang, and Luau's lang = "zh-TW" on any element or span. It is inherited by what the element holds. Its Han characters take that language's fonts, ahead of the app's locale and of what a line's kana or hangul say, so a Chinese quote in a Japanese app is drawn in a Chinese face. Screen readers are given it as the text's language. The fork's fallback search keeps simplified, traditional and Hong Kong Chinese lists whatever the locale.
  • View::not_contents (zgx): undoes contents, so a region built by code that set it can be put in a flow of the host's choosing (with display_contents, its children in its parent's).
  • WebViewOptions::accelerated (Luau accelerated; Linux only, macOS and Windows ignore it): on by default. Off, WebKitGTK paints the page on the CPU and zgx copies and uploads only what each frame changed, as up to four rectangles, instead of the whole page WebKit's compositor reports on every frame. A 40 × 40 spinner on a 1076 × 700 page uploads about 3,300 pixels a frame instead of 753,200, and WebKit's web process drops from 40–52% of a core to 3–9%. Painted pages draw no backdrop-filter and flatten 3D transforms.
  • A web page's full screen (zgx WebViewState::full_screen, WebView::exit_full_screen; Luau web.full_screen, web:exit_full_screen()): a page's requestFullscreen is told to the app, tracked like the page's other state, on every platform. On macOS it now works, in WebKit's own window over the screen (WKWebView's element full screen was off, so pages' requests failed); on Windows and Linux the element fills the page's node, which an app can grow, or make its window full screen, to show it so.
  • A web page's context menu on Linux (zgx-desktop's webkitgtk): a right click shows WebKit's menu for what's under the pointer, a link (open, open in a new window, download, copy its address), an image, media, a selection or field (copy, cut, paste, select all), the page (back, forward, reload, Inspect Element), as a zgx menu where the click was. It showed none: GTK's own would open off the page. Spelling, font and media-control items are left out.
  • Drags out of a web page on Linux (zgx-desktop's webkitgtk): a page's link, image or selected text drags as zgx's own drag. It drops on zgx's targets as DraggedText (the selection, or the address), and out of the window on other apps over XDND or Wayland's data device: the address, the text, and an image's bytes from WebKit's own copy, so a page behind a login drags its images too. A selection goes as plain text.
  • WebView::print (zgx): the platform's print dialog for a web page, as the page's own window.print() shows it. On macOS both are now the print panel as a sheet on the window (the page's window.print() did nothing); on Windows WebView2's print preview; on Linux GTK's print dialog, now transient for the app's window on X11 (it opened wherever the window manager put it, owned by no window it knew).

Performance

  • The core benchmarks are cheaper than in 0.1.7, all but the lab's stream (below) (exact instruction counts at the release on Linux arm64): micro-state −36.5%, the lab's scroll −25.9%, heavy scrolling −16.6%, the other micro benchmarks −17 to −31%, the heavy streams −2.7%, animation −4.1%, mount −1.6% and 3d-mixed −2.2%. Updating a script's state costs 3.98% less, measured with the same benchmark on both sides (the gate's −27.4% counts the benchmark's own setup at 0.1.7 only, since #1321). Script layout, anime, style, list-state and spans-follow are flat (−0.11% to +0.02%).
  • Every example app's interactions cost less, from −0.12% (app-mail) to −3.79% (app-code).
  • The lab's stream costs 0.37% more: Linux's system font cache (#1307) makes startup 9.3 M instructions cheaper, but the thread that checks it makes glibc lock its allocator in a process that otherwise has one thread, as this headless benchmark does (about +12 M). Apps with a window already have threads. The next release fixes it.
  • 3D shadows find their pipelines by one byte (zgx-3d): a frame drawing shadows looked up each run's shadow pipeline by a tuple of flags through the standard library's SipHash; it now uses one byte under the variants' own hasher. 3d-mixed, which draws shadows, falls 2.2% (257 K instructions a frame).
  • display = "contents" in a column or row costs what a box does (zgx): its parent lays its children out as its own with zgx's own column and row layout, not taffy, unless they need taffy as its own children would. 500 rows in a column: 6.0 M instructions to mount and 0.54 M each relayout, against 9.2 M and 1.2 M before (a box: 5.9 M and 0.30 M).
  • A long text keeps its edits only for a reader that follows them (zgx): every edit of a long text (a keystroke in an editor on a long document) recorded itself in the text's log, read or not; a text now records edits only once a reader that follows it by them asks (Text::keep_edits: an editor bound to it, when the value changes from outside, and ui.markdown_view), and otherwise only takes a new id. A stream into a bound editor takes its first token whole, then each one as it is.
  • A streaming Markdown paragraph is mended from where it got to (zgx-script): while a block streams, the hanging-marker repair (**bold shown closed) scanned the whole block into a vector of chars on every append; it now keeps its scan and reads only the bytes appended. An append into a 6 KB paragraph costs 17–20% fewer instructions (13% with 256 paragraphs above it) and its peak heap is up to 23% lower; the repairs are the same, checked against a fresh scan of every prefix.
  • Linux reads its system fonts from a cache (zgx-gpu), as macOS and Windows do. At every launch fontdb parsed fontconfig's configuration and opened every installed font. With 113 fonts that cost 11.7 M instructions; from the cache it costs 0.46 M (-96%). The cache lives in $XDG_CACHE_HOME/zgx/ (or ~/.cache/zgx/). It is used while the configuration files fontconfig read, the font directories they name and the environment fontdb reads (HOME, XDG_CONFIG_HOME, FONTCONFIG_FILE) are unchanged, and it keeps the generic families fontconfig's aliases chose. A launch that finds them changed loads the fonts as before and writes the cache again, once. The cache file's format is now 4 on every platform, so each rebuilds its cache once.
  • Variable-height lists pay for keeping their place only when they load earlier pages (zgx): the key of the row a list holds in view, kept so rows added above it leave the view where it was (on_start), is no longer carried by every list's scroll and layout pass.
  • A Markdown view follows a long reply by its appends (zgx, zgx-script): ui.markdown_view { "{reply}" } reads the state's text where it lies, rather than copying it into a string each update; a long reply streamed in with reply:append(token) (Rust: the new Shared::append) is parsed from the inserts its text keeps (the new Text::id and Text::inserts_since), with no copy and no comparison of the document. With 256 paragraphs, an update costs 2.4% less when the reply is set whole (at the same or lower peak heap) and 6.7% less when it is appended to (the long text keeps its last edits, about 4 KB). Any other edit reads the text whole, as before.
  • A parent's new percentage bases read its children's cached bits (zgx): when a taffy-laid-out parent's bases change, it reads each child's percentage flags from the bits cached with what the child reads (OWN_PERCENT_*) instead of working them out from its styles each time. x86: widgets −0.08%, mount −0.06%, micro-state and the scroll scenes −0.05%, app-chat −0.04%, every cell ≤0. arm64: mount −178K instructions, micro-vscroll-variable −78K, heavy-stream −40K, app-chat −29K, app-mail −20K (#1276).
  • A hot reload compiles only the files that changed, and a save that changes nothing reloads nothing (zgx-script): every module was compiled again on each reload. A hot-reloading host now keeps each file's bytecode by what the file held, for the files of the last load alone, so a long session's edits don't grow it; every module still runs again, as before. A watcher woken for files whose bytes are what is loaded (an editor saving the same text, a checkout touching times) no longer reloads, so the app keeps its state. In an app of 170 modules (466 KB of Luau) a reload after one module changed takes 6.5 ms where it took 14 ms, and an unchanged save 0.15 ms where it reloaded in 14 ms. A host that loads once keeps nothing. Compiled files are shared by every host and VM on a thread, by their bytes, so the same text compiles once wherever it loads.
  • A row built again allocates and copies less (zgx, zgx-script): a view's children are given exactly as many slots as there are (a growing vector reserved four, 2.5 KB, for a container of one); a script element's static styles, its children's flow and its wrappers no longer move the 632-byte view in and out on the way; a ui.each row's identity is one allocation and its key is compared as it is written; shared state republished builds each changed list or record once, not as a vector copied. update_bench rows, whose changed rows are built again, fall 2.1% of their updates (9.6 M instructions in 200), rows updated in place 0.9%.
  • A script element's style keys are found by their atoms (zgx-script): each property key a Luau table names (w, bg, text_size) is now known by the atom Luau keeps in the key string, given once per string, instead of through a map keyed by the string's heap address. A lookup costs the same whatever the heap's layout (an unrelated change no longer moves it) and less: fill_from −20%, micro-vscroll-variable-luau −0.48%, script-update −0.14%.
  • A table a script returns reaches Rust without a copy of its type check (zgx-mlua 0.12.7, zgx-script): a code editor's highlighter result, a row builder's and every other table result is referenced as it lies on the stack. app-code and app-code-search run about 150K fewer instructions, script-update 562K.
  • Script state finds and compares table keys without calling libc (zgx-script): a table of a few fields is scanned for an equal key, and keys and short strings compare with a few word loads. A republished list matched by id costs 0.7% less an update (script-update), and its cost no longer moves with where memcmp's bytes land from build to build (#1273).
  • A terminal reads streaming output once a refresh (zgx-terminal): an engine-drawn terminal read its session and worked its rows out again for every chunk of output, about a thousand a second where Windows' ConPTY hands output over in small chunks, though no more than one frame a refresh shows. Output arriving faster than the display refreshes is now read at the next refresh, all of it at once; output after a pause (a key's echo) is still read as it arrives. NodeHandle::refresh_interval gives the display's refresh period to code like it (zgx).
  • A text area shapes only the line an edit changed, at any length (zgx): a text area under 64 KiB was laid out whole on every change. Its caret layout shaped every line again, so a token streamed into a 16 KB reply cost 20.5 M instructions (1.16 ms) in a shaped window. A text area of more than one line is now laid out a line at a time, as long documents were (one line is shaped whole either way). A change's text is derived from the last one by a one-chunk edit, and a bound text's line-ending check reads it a block at a time. A token now costs 96 K instructions at 16 KB and 82 K at 1 KB (3.7 M before), in line with 73 K at 128 KB. Shown a line at a time, a text area keeps its placeholder, its ranges for input methods (EditorHandle::text_area) and the geometry assistive technology reads of each character (Semantics::set_text_lines). A line height under a point is kept as it is, no longer rounded up to one.
  • A text that changes to one measuring the same is repainted, not laid out again (zgx): a counter or a clock (a text that doesn't wrap, as long as before) is measured as it changes, and if it measures as before nothing around it is laid out again. arm64: micro-state −20.1M instructions, script-update −16.6M, micro-state-luau −8.3M, app-dashboard −2.2M; i18n_bench's frame 87 → 34 µs (#1288).

Fixed

  • Chinese text draws on macOS 26 again (zgx-cosmic-text, zgx-gpu): a font face with no outlines zgx can draw, such as macOS 26's PingFang (its shapes only in Apple's hvgl table), is passed by in fallback, and Chinese takes Heiti SC or TC instead. In 0.1.7 every Chinese character on macOS 26 drew as blank space.
  • An editor's undo and redo don't break after an app answers an undo (zgx): a document loaded (load_next) as an answer (answer_next) to an undo kept the step that redid the text before it, and an answer as long as the text kept the steps before the undone one. Undoing or redoing them then broke the text, or panicked out of range or inside a character. A load now leaves nothing to undo or redo, and an answer to an undo nothing older to undo. Controlled fields that answer what is typed, as Zeron's do, reach these paths.
  • Apps on different zgx versions keep a system font cache each (zgx-gpu, macOS and Windows). The cache was one file, so two apps whose zgx read different formats each rewrote what the other had written, and both loaded every font at every launch. The file is now named for its format (system-fonts-v3). Another format's file, or one left half-written, is removed once it has gone unchanged for 30 days; an app keeps its own file marked as in use.
  • Text measured without a renderer no longer keeps every word it shaped (zgx-gpu, zgx-cosmic-text 0.19.8). A renderer trims cosmic-text's word cache as it draws. Headless hosts, tests and servers measure through TextServices, and nothing trimmed theirs, so it grew without bound (about 2.7 KB a frame for 30 churning labels). The text cache now sweeps the word cache as it grows, letting go of words unused lately, so it levels off (30 labels churned through 450,000 values: about 49,000 words, where untrimmed it reaches 105,000 and climbs). TextServices::release_unused empties prepared text and words at once, for a host returning to its baseline after a batch. TextServices::text_cache returns its cache, as a renderer's does.
  • A long text streamed into gives back its edits once the stream stops (zgx, zgx-script): the last edits a long text keeps for its readers (an editor or ui.markdown_view following a reply by its appends) stayed for as long as it did; they now go as the host goes idle (Text::forget_edits), so a reply streamed in holds what the same text set whole does. Appending to a short string copies it once rather than twice, so state:append and Shared::append never cost more than setting the joined text.
  • A keystroke in a long bound document no longer reads all of it (zgx). Whether the bound text needed its line breaks normalized was found by scanning every chunk, on every keystroke. A text now counts its carriage returns where it is made and in the chunks an edit makes again, so the check is constant time: a keystroke on a 100,000-line file costs 1.8 M instructions, down from 5.3 M. A short bound text now takes each edit where it is, rather than a new copy of the whole text, and the editor doesn't compare the value it has just written.
  • A new paragraph is prepared from its words (zgx-gpu). A paragraph that cosmic-text shapes as one left-to-right span, plain or rich, is now measured and laid out from its words. Each word is shaped once and shared by every text that holds it. Before, every new text built a cosmic-text line around its cached words, then copied their glyphs and laid them out again. Glyphs, positions and sizes are cosmic-text's, bit for bit. text_bench (prepared) measures 1,000 new paragraphs in 5 ms instead of 19, and streams one in 8.5 ms instead of 32. A label whose text changes every frame costs 13.5 K instructions to measure, not 23.7 K; wrapped, 38 K, not 89 K. Lines with tabs, right-to-left text, hyphenation, letter spacing, fallback families or a word across runs take the old path.
  • A Japanese or Korean line's min-content is measured in its language (zgx-gpu). Measured from its one-word-a-line copy, as some lines are, a word of kanji alone lost the line's kana and took the system language's Chinese face: 11.23 px where the line gives 11.0. The copy now takes the line's language.
  • A touchpad scroll comes to rest on a whole device pixel on Linux (zgx-desktop): a two-finger scroll and the coast after the fingers lift could leave what they moved resting between pixels (a canvas view at x 86.502), its text and hairlines blurred, where the wheel's scroll eases in whole pixels. Its last step now brings the scroll's whole motion to a whole number of device pixels, at the window's scale and zoom, by under half of one: no visible jump, and fractions still while it moves.
  • A drag let go as an earlier drop finishes drops on Wayland (zgx-desktop): once a drop is performed, the window's own drag ends there, taken, and its next drag goes to the compositor at once, while the earlier drop's target is still finishing with it; that drop's end, coming later, is no longer taken for the newer drag's. A tab grabbed straight after a drop moves to another window or tears off as one grabbed later does (#1259).
  • A web page's file input opens the window's file dialog on macOS and Linux (zgx-desktop): <input type=file> asks through WebView::choose_files, the window's own file dialogs (a sheet on macOS; the desktop portal's, or zenity's, on Linux), and what's chosen goes to the page, several files where the input takes several and a folder for webkitdirectory on macOS. On macOS it opened nothing; on Linux GTK's chooser opened as a window of its own, apart from the app's.
  • A web page's cursor on Linux is the one it sets, as it sets it (zgx-desktop's webkitgtk): the cursor was read just after each pointer event, before WebKit's web process had placed the pointer, so it showed the previous one until the next move (a link's hand, after stopping on it, stayed an arrow); and an image cursor (cursor: url(…)) showed as the arrow. The window now follows the cursor WebKit sets as it sets it, and shows a page's image cursor itself.
  • A web page's alert, confirm and prompt show on macOS (zgx-desktop): each is an alert sheet on the page's window, with the page's origin under its message and a field for prompt, and the page's script waits for its answer. They returned at once before: alert showed nothing, confirm was false and prompt null.
  • A web page's copy reaches other apps whole on Wayland (zgx-desktop's webkitgtk): a selection the page copies goes out with its HTML, so it pastes formatted elsewhere, and an image it copies (its clipboard API, a canvas) as a PNG. It went out as text alone, and an image not at all. The clipboard is now also read after any key, not only one with Control or Shift, as a page's own key handler can copy.
  • A script on Windows isn't stopped short of its time budget (zgx-script): Windows counts a thread's CPU time a scheduler tick (15.6 ms) at a time, so a call that used 25 ms could read as two ticks, 31.25 ms, and be stopped under a 30 ms budget it hadn't spent. A budget's CPU time now counts as spent only a tick beyond it there; a runaway script stops up to that much later.

Crates: zgx, zgx-components, zgx-gpu, zgx-3d, zgx-desktop, zgx-terminal, zgx-script, zgx-run and zgx-ghostty-sys 0.1.8.

Known issues

  • On a heavily loaded macOS machine, a runaway script can run up to ~150 ms past its time budget before it's stopped; fixed in the next release.