The top image was the mail.tax screenshot. Swap in the painted-sky
dashboard and match the caption to the glass window, cards, and schedule.
Session: ses_f354b12f6ffecM3jsw9hX59RHp
Drop the previous GPU image when src or a live upload replaces it, and when the img node is pruned. Without drop_image, every setImagePixels frame leaked a RenderImage.
scrollIntoView now uses the virtual-list logical index, not the windowed child index. A windowStart of 50 plus child 5 now scrolls to item 55.
Attach setImage, setImagePixels, and scrollIntoView in getPublicInstance instead of createInstance, so concurrent React can abandon a host node before the methods exist. Pass the original buffer through instead of copying it with Buffer.from.
The waveform test compares two live phases. Encoded setImage and windowed scrollIntoView have screenshot and list tests.
Session: ses_f3c07efdbffeHwbaQhsE7fIz5z
Add website/src/guides/solid.mdx covering install, preload, render,
primitives, motion, Select, testing, and automation. Link it from
the Guides nav and from the README Solid section.
The Solid AnimatePresence test now wraps the exiting motion.div in
Show. A boolean && child is not a tracked hole, so the previous
test never actually unmounted.
Session: ses_f3c074549ffe2jtrJMYbbLhqMx
The README live-image example encoded PNG via canvas.toBuffer.
node-canvas already exposes packed RGBA through getImageData().data,
which is what setImagePixels wants.
Switch the example to a 2x bitmap (1600x160 into an 800x80 box) and
push ImageData instead of PNG. Call out that toBuffer('raw') is not
RGBA: it is BGRA or ARGB, native endian, and may include stride
padding.
The waveform example still writes the same RGBA layout by hand.
Session: ses_f3b99a94affe1b6zCIvuV8WoPt
`<img>` refs can push image bytes without a data URL or JSON mutation.
`setImage` takes encoded PNG, JPEG, WebP, GIF, SVG, BMP, TIFF, ICO, or
Netpbm. `setImagePixels` takes packed RGBA. Prefer pixels for a live
waveform. There is no density argument. Upload a 2x bitmap into a 1x
layout box on retina.
Every host ref now has `scrollIntoView()`, which scrolls the nearest
overflow parent or `<virtual-list>` until that node is visible.
The waveform example paints a generated 2x RGBA buffer through
`setImagePixels`.
Session: ses_f3c07efdbffeHwbaQhsE7fIz5z
Stop copying napi wire types in `@gpuix/native/host`. Re-export
ElementBounds, HighlightMatch, PathPromptOptions, EdgeInsets, and
overlay stats from the generated addon types.
Helpers now ask only for the methods they use:
- createMutationQueue takes MutationHost (applyBatch)
- window observers take WindowSizeHost / WindowInsetsHost
- selection observation takes SelectionHost
NativeRenderer stays the adapter-facing type: required applyBatch,
plus live renderer methods as Partial<Pick<GpuixRenderer, ...>>.
Fakes can still implement applyBatch alone. Do not subclass the
napi GpuixRenderer.
Session: ses_f3c88f82affeXgsQdmQW4wpizp
Add the Solid quick start, shared native runtime architecture, package build instructions, and framework parity rules to the public contract and contributor guide.
Build and test Solid in the platform matrix, then publish it after @gpuix/native beside the React adapter.
Session: ses_f4102f732ffesSfYYRRHlXA2j9
Keep leaving motion nodes mounted until native motion reaches the exit target, matching Motion for React. AnimatePresence holds the child, motion.div swaps animate to exit while isPresent is false, and motionComplete then unmounts it. Without AnimatePresence, unmount stays immediate.
Native MotionState now reports just_settled once when a track reaches its current target, including zero-duration retargets. GpuixView emits motionComplete after the build, the same way highlight events flush, so a setState in the handler cannot re-enter the frame.
Wire onMotionComplete through host types and the reconciler. Export AnimatePresence, usePresence, and useIsPresent. Document the API, add GPU-backed unmount coverage, and add a minor changeset.
Session: ses_f40bbeaeeffebG77zwP6ZNd8m0
Move visibility and opacity, including hover and active refinements, onto the outer anchored FloatingLayer surface. Nested opacity no longer multiplies against the deferred fallback fill.
pointerEvents none now disables the anchored occluder so a hidden or non-interactive overlay does not steal hits. Background, border, shadow, overflow, and layout stay on the inner content.
Extend the retained-tree snapshot so hover and active surface styles, content opacity stripping, and occlude false are covered. Document the overlay contract in the README and the pending changeset.
Session: ses_f4fec2f63ffeX4htZahVSoX5f6
Expose minimizeWindow, zoomWindow, and toggleFullscreen through the native renderer and React renderer contract.
Dispatch macOS operations directly through the embedded window and route Windows, Linux, and FreeBSD operations through the GPUI UI command channel.
Document the desktop-only API, regenerate the N-API declarations, and add a production binding regression test plus a minor changeset for issue #68.
Session: ses_f41046982ffe9HBet3NGzDDJXd
Copy uniform and per-corner border radii from FloatingLayer content to the outer anchored surface. This prevents the deferred fallback background from showing square corners behind Select, Combobox, and Tooltip popups.
Add retained-tree snapshot coverage for every supported radius property and document the overlay behavior.
Session: ses_f4fec2f63ffeX4htZahVSoX5f6
Expose promptForPaths through the desktop renderer and React renderer contract. The promise resolves selected absolute paths, returns null for cancellation, validates unsupported option combinations, and rejects on browser builds.
Route Windows and Linux requests through the GPUI UI command channel. Settle all desktop results through napi-rs JsDeferred without holding a libuv worker for the lifetime of the operating-system dialog.
Keep the capability optional for injected mutation-only renderers. Add native option tests, a production deferred rejection test, test-renderer cancellation coverage, generated declarations, public docs, and the Windows GPUI cancellation caveat.
Session: ses_f4fec2f63ffeX4htZahVSoX5f6
Draw input and textarea carets at the full line height so the bar matches the painted editor row.
Propagate paste shortcuts when the clipboard is empty, contains only an image, contains external paths, or belongs to a read-only editor. Keep ordinary text and mixed text-plus-image clipboard content on the native text insertion path.
Add Rust and React regression coverage for clipboard classification, element and window event propagation, and caret geometry.
Session: ses_f4fec2f63ffeX4htZahVSoX5f6
Consume the pending changesets into a minor release. Users get a window-level onSelectionChange callback for text selection, a live-window click panic fix, and docs to pin @gpuix/react and @gpuix/native to the same exact version.
Bump the native Cargo crate, native npm package, React package, generated napi loader version checks, and Bun workspace lock to 0.9.0. Keep the published React dependency on @gpuix/native as workspace:^. CI is the only publish path for native platform binaries.
Fixes#38
Session: ses_f56207a65ffeFBg1JxfiwGIPqH
React apps can now react when the selected text ranges change, which is the
gap that blocked porting termcast onto gpuix. Selection is app-wide and
rebuilt at paint, so this is a root callback on render() / createRoot(),
the same attachment as onKeyDown, not a per-element prop.
Native emit reads the same SelectionState as getSelectedText and keys on a
span identity hash, so an unchanged frame does not fire. Empty on mount is
not a change. A later clear fires once with value omitted. The payload is
a normal EventPayload; value is the joined selected text.
```
drag / clear ► SelectionState.identity() ► emit selectionChange
► handleGpuixEvent
► onSelectionChange(event)
```
Session: ses_f59f89012ffecnPBB1A40P5don
A physical left click still aborted 0.8.0 with
`cannot update GpuixView while it is already being updated`.
0.8.0 already dispatched automation mouse through AnyWindowHandle,
so that path no longer leased the root view. AppKit still does.
The text-selection mouse-up listener then nested-updated the same
GpuixView while GPUI held the lease.
A tap never started a drag, so skip drag-end cleanup there.
Real selection-drag move and end work now run through App::defer,
after the current GPUI effect cycle returns the root lease.
The test renderer now leases GpuixView the same way AppKit does
for mouse down, move, up, and click. The old AnyWindowHandle path
hid this panic. Cover it with a click that must not abort.
Fixes#38
Session: ses_f5bf1a57bffekyaF7gpwuhWzPr
Drop the keyword dump that told people to search for GPUI React. Lead with
what GPUIX is, then send users to bunx @gpuix/cli new instead of a local
examples/ command that needs a native build.
Repo example commands stay later, with a note that they need a clone.
Session: ses_f5eb2b952ffeq1yIyyzc0zuYur
GPUI uses a flat painted hit list and does not bubble clicks. A custom row
with its own background can therefore cover SelectItem or ComboboxItem and
prevent selection, hover state, and popup close behavior.
Add asChild to both item primitives through the existing renderSlot path.
The custom row becomes the host item itself, so it owns one native hit target,
one event id, the item ref, composed handlers, state styles, and disabled
selection behavior.
Migrate every chat picker to asChild. MenuRow now forwards its ref and host
props, while keeping its own row padding. Add end-to-end tests for filled
Select and Combobox rows and a chat regression assertion for menu row height.
Document when to use asChild, including the ref and host-prop forwarding
contract. Add a React patch changeset with the new public API.
Session: ses_f61007e8fffe0tRyMx0uRPPeCZ
Browser WebGPU creates its public window handle before the internal GPUI window can accept updates. Calling focusElement from a React mount effect therefore threw GPUIX web window is not ready even though WEB_WINDOW was already present.
Store the latest browser focus target outside the window update path. Consume it during GpuixView render, after the window is active, and apply it after focus handles are synchronized. Explicit focus keeps precedence over autoFocus.
Use the same deferred focus state on desktop when a requested host element does not have a focus handle yet. Clear an older pending request whenever a newer request focuses an existing handle, so stale state cannot steal focus on a later render.
Document startup queuing and the latest-request-wins rule. Add a native patch changeset for the browser API behavior.
Session: ses_f61007e8fffe0tRyMx0uRPPeCZ
Each sidebar row now owns its own transcript. Clicking a thread paints
that conversation. New Task prepends a blank Today thread and clears
the composer. Sends append the user turn, then a demo assistant reply
that says this is the GPUIX chat demo. Retry rebuilds that last reply.
History arrows walk a stack of thread ids. Search filters titles.
Settings shows a short note and can cycle the frame overlay. The
inspector lists the current thread, model, reasoning, access, and
mode. The list filter keeps only threads for the selected project.
Tests cover thread switch, new task, demo reply, inspector, and
history. The live launch wait looks for GPUIX chat demo so the quoted
user text cannot match twice.
Session: ses_f61007e8fffe0tRyMx0uRPPeCZ
The Holocron title, docs.json description, and README lead now say GPUI
and React for native apps, not only native React on the GPU. The hero
tagline is GPUI and React / for native apps. Keywords on the homepage
frontmatter are GPUI, GPUI React, GPUI TypeScript, and native GPUI app.
The shader overlay uses a 0.7 alpha multiplier instead of a dark/light
opacity class, so the flare stays visible behind the new copy.
Session: ses_f64f287b1ffeD0rCw6d52oXfHk
layout_text used window.line_height() after Taffy measure. Parent
with_text_style is gone by then, so the row was always 16×φ no matter
what React passed. A 28px font still sat in a 26px box. Issue 63.
Use the TextStyle captured during request_layout instead:
style.line_height_in_pixels(rem_size). Without an explicit lineHeight
that follows GPUI default leading, so a larger fontSize grows the box.
Pass lineHeight to set the row in pixels. minRows and maxRows still
multiply that height. An explicit height still wins.
Tests assert:
- textarea height equals lineHeight
- minRows=3 with lineHeight=30 is 90
- fontSize=28 with no lineHeight is 45 (28×φ)
- a single-line input honors lineHeight too
Session: ses_f79437cb5ffennyb8lTdU6KH7Q
The package used to export ./floating from dist/components/floating.js, which is the internal module for Select, Combobox, and Tooltip. That surface listed useControllableState and useFocusTrap as public helpers.
useFocusTrap is already gone from the implementation. It listened for Tab on a panel ref and forwarded it to focusNextWithin / focusPreviousWithin. Those renderer methods are the real scoped-tab API. A thin hook on top of them also fought a window-level Tab handler, because both moved focus and neither could stop the native key.
src/floating.ts is now the published entry. It re-exports FloatingLayer, renderSlot, and the style helpers libraries actually need. package.json points ./floating at dist/floating.js.
Docs and the pending Select changeset now match that:
- trap Tab by owning onKeyDown, then calling focusNextWithin / focusPreviousWithin
- do not also call focusNext from an element onKeyDown when a window Tab handler is already installed
- the floating table lists FloatingLayer and renderSlot only
Session: ses_f7fa3a82effee2tmI4o1tW6YzS
GPUI already turns an OS FileDropEvent into an ExternalPaths drag and
delivers on_drop to the hovered hitbox. Wire that onto host elements the
same way onClick works. Nested targets keep working because GPUI stops
propagation after a matching drop.
```tsx
<div
onFileDrop={(event) => openFiles(event.paths ?? [])}
style={{ width: 400, height: 300 }}
/>
```
event.paths is string[] of absolute Unicode filesystem paths. event.x and
event.y are the drop point in window pixels. An empty drop, or a drop that
contains a non-Unicode path, does not fire. to_string_lossy would invent a
path that does not exist on disk, so conversion uses Path::to_str instead.
Works on div, text, img, svg, input, textarea, code, markdown, diff, and
anchored. virtual-list is not a host div and does not take this event; wrap
it. Desktop only. Tests simulate Entered then Submit through GPUI.
Session: ses_f7f7c408bffe5d59D85FJmrsKT
The previous array form could not grow. Extra fields such as scroll
offsets would have to sit at magic indexes. Native napi, wasm, the test
renderer, automation, and every call site now use named fields.
Session: ses_f83f90209ffeVmkdjhaBehDTP7
The feed file was a workaround. GitHub already has tag_name, assets, and
a sibling .sig. checkUpdate now hits api.github.com:
GET https://api.github.com/repos/OWNER/REPO/releases/latest
Rewrite github.com/OWNER/REPO, /releases/latest, and
/releases/latest/download/... to that API URL. Match the host bundle
(*.app.tar.gz, *_{arch}.AppImage, *_x64-setup.exe / *_arm64-setup.exe)
and GET {name}.sig. Missing sibling signature is an error. Infer format
from the asset name.
Keep packager JSON as a silent fallback when the body already has
version plus url or platforms. Do not document that path.
CI uploads only what packager writes: the signed bundle and its .sig.
README and the changeset now show GitHub Actions plus
checkUpdate against https://github.com/OWNER/REPO/releases/latest.
Session: ses_f837ecfbeffeynBTQx5bKyvN9d
Port cargo-packager-updater 0.2.3 into packages/native/src/updater.rs
instead of depending on the crate. The original crate pulled crates.io
reqwest blocking, a second TLS stack next to Zed zed-reqwest. HTTP now
goes through reqwest_client, the same client <img> already uses.
JS:
import { checkUpdate } from '@gpuix/native'
const update = await checkUpdate('0.1.0', {
endpoints: ['https://github.com/OWNER/REPO/releases/latest/download/latest.json'],
pubkey,
})
if (update) await update.downloadAndInstall()
The feed is 204 or a latest.json with platforms keys like macos-aarch64.
downloadAndInstall() replaces packaged files and does not relaunch.
Desktop only. The browser wasm build does not export this.
Original: https://github.com/crabnebula-dev/cargo-packager/blob/v0.2.3/crates/updater/src/lib.rs
Session: ses_f83f922a9ffe9QbIBVQESIXTQM
Select no longer walks children by `child.type === SelectItem`. Root `items`
is optional and only a label lookup for SelectValue while the popup is
closed. Keyboard nav and clicks read mounted SelectItem children through
registerItem. Disabled lives on Item. A styled wrapper around Item works.
Without items, SelectValue shows the raw value.
Register items in useLayoutEffect, not a callback ref, so a middle item
can re-render without jumping to the end of the list. selectValue rejects
unmounted and root-disabled items. A late-mounted selected item becomes
the highlight.
Native:
- getFocusedElementId, focusNextWithin, focusPreviousWithin walk GPUI's
painted TabStopMap via focus_next_among / focus_prev_among
- visibility: hidden maps to GPUI invisible()
- getElementBounds is typed on NativeRenderer
JS:
- export Props, GpuixTheme, and host prop types from @gpuix/react
- export FloatingLayer, useFocusTrap, and friends from @gpuix/react/floating
AGENTS.md: built-in headless controls follow Base UI's Root-data vs
children split.
Fixes#59
Session: ses_f83f90209ffeVmkdjhaBehDTP7
A raw Mach-O has no icon. cargo-packager wraps the binary in a .app.
Pass an .icns, not a 1024 PNG. cargo-packager rejected a 1024 PNG with
No matching IconType.
examples/packager.json packs the Bun chat compile as one main binary.
hermes/packager.json lists gpuix-hermes as main and the .node as a
second binary, not a resource. Resources land in Contents/Resources.
Hermes dlopen looks next to the exe, which is Contents/MacOS.
README documents the flow: install cargo-packager, build AppIcon.icns
with sips + iconutil, then cargo packager --release --config packager.json.
formats is host OS only (app/dmg, nsis, appimage). On this machine the
Bun chat .app is 82 MB and the Hermes counter .app is 34 MB.
Ignore packager output: examples/bundle/, examples/AppIcon.icns,
hermes/bundle/, hermes/AppIcon.icns, and tmp-icons/. Do not track
generated hermes/chat.cjs.
Session: ses_f84b88b16ffePB3X7Fqzot47OY
Add a Holocron guide at website/src/guides/hermes.mdx and link it from the
README. The page covers rebuilding hermes-node on macOS (the published
tarball dead-strips napi_*), bundling React to CJS with bun build, and the
measured ship set: 12 MB executable plus a 22 MB native sidecar.
A hermes/ prototype sits next to the docs so the same path can be rerun.
Session: ses_f84b88b16ffePB3X7Fqzot47OY
GPUI already talks to the macOS AX tree, Windows UIA, and Linux AT-SPI
through AccessKit. GPUIX never set .role(), so VoiceOver saw an empty
window. A node is in the tree only with both an id (already set) and a
role.
Prop names match React DOM. Role values are ARIA tokens.
```tsx
<div
role="button"
aria-label="Delete note"
aria-id="notes.delete"
onClick={remove}
>
Delete
</div>
```
- `none` / `presentation` produce no node
- `<text>` defaults to Label, `<input>` to TextInput, `<textarea>` to
MultilineTextInput, `<img alt>` to Image
- onClick registers AccessKit Click, so VoiceOver Press fires the same
JS handler
- Tests dump GPUI debug_a11y_tree_json after paint
The zed submodule picks up two GPUI hooks: tests can activate the a11y
tree without a screen reader, and Img / Svg now report .role() instead
of dropping it.
Browser / wasm has no AccessKit adapter. These props are no-ops there.
Fixes#47
Session: ses_f89a78b8cffe4lrrAfJ8Uz4sH1
A throw used to keep the window alive but empty. render() now paints the
error message and stack, and Reload remounts the last tree.
Unhandled React render errors, uncaughtException, and unhandledRejection
all take this path. The overlay is scheduled on a microtask keyed to the
failing root, so a later remount does not paint a stale overlay. Process
handlers uninstall on resetRender.
Save under bun --hot still remounts too.
Session: ses_f941afdedffezh2lODSRNO04A8
Desktop GPUI defaults to NullHttpClient, so a remote URL never loaded.
Install Zed reqwest_client on native apps so img(SharedUri) can fetch in
the background. Wasm already has fetch.
A definite width and height now also set aspect_ratio. GPUI otherwise
fills that from the bitmap after decode and jumps the box. Tests use a
FakeHttpClient that returns the same SVG as the disk fixture, so the
dispatcher never parks on a real network.
Set both width and height. Failed loads still show the existing
fallback. A loading URL paints an empty box of the declared size.
Session: ses_f9810208bffeUeHRs8rtxe7KaD
A search pill with extra height used to paint text at the top of the box,
and rounded corners did not clip the glyphs. HTML inputs center and clip.
Single-line inputs now use items_center when given extra height, and
overflow_hidden when borderRadius is set. Document the no-default-padding
gotcha next to the other CSS-looking style traps.
The padding coverage test checks that paddingLeft actually insets painted
text, which is how a pill wrapper is supposed to work.
Session: ses_f9922154effe0jqPuJbXGeDNke
Plain Enter used to always fire onSubmit on both input and textarea, so a
normal multiline editor could not insert a newline, and Enter did nothing
when no onSubmit listener was set.
Textarea now uses a separate key context. Enter and Shift+Enter insert a
newline. When onSubmit is present, Enter submits and Shift+Enter still
inserts a newline. Input still submits on Enter.
Adding or removing onSubmit after mount swaps the key context, so a
composer that only submits after the user types still gets the right
Enter binding.
Fixes#46
Session: ses_f998cca76ffexsRUJHhI2AdZeA
GPUI already paints those decorations. This wires `"underline"`,
`"line-through"`, and `"none"` through StyleDesc, apply_styles, and the
React StyleDesc type so a React tree can request them.
Visual coverage compares decorated text against the same glyphs with no
decoration so a missing native apply cannot hide behind a type-only
change.
Session: ses_f9922154effe0jqPuJbXGeDNke
The homepage README now opens on the Superhuman-style mail client
sitting on the desktop wallpaper, not the chat window. Alt text is
`mail.tax example`. The launch snippet is `bun --hot mail.tsx`.
The committed JPEG is a window capture composited onto the Tahoe
wallpaper so the lake shows around the rounded window. Full-screen
capture cannot see other apps on this machine.
Also land the mail example itself: three panes, thread list, reading
pane, and the Framer newsletter assets.
Session: ses_f92fa1015ffeSFgm8TqqfEZnVb
On macOS, JS owns the event loop. startFrameLoop calls renderer.tick()
about every 8ms, and that tick pumps AppKit. A throw that escaped the
timer stopped the next setTimeout, so the window froze. bun then often
exited, which looked like a crash.
startFrameLoop now catches errors from tick() and still schedules the
next pump. Native event callbacks catch throws from React handlers so
they do not become napi_fatal_exception. render() installs
uncaughtException and unhandledRejection listeners so bun stays alive,
and it starts the frame loop before the first React flush so a throw
during mount still leaves AppKit pumping. The loop is not restarted on
remount.
The error is logged. There is no auto-reload. Save under bun --hot to
remount.
Session: ses_f97da32b5ffejnj7pvF2xzbkXL
GpuixRenderer.tick() already drains only ready AppKit events. The README
now says that, and events.test.tsx checks that 30 idle ticks return in
under 200ms so Bun timers and sockets can run between frames.
Fixes#39
Session: ses_fa1101bf5ffexVlY2PD1MZjRSg
Dispatch click, hover, wheel, and drag input through AnyWindowHandle on desktop and browser hosts. Mouse listeners can now update GpuixView during normal GPUI event delivery without triggering a nested entity lease and aborting the process.
Cover the production renderer with a child-process automation test that clicks the live chat sidebar, waits for the state change, then drives keyboard input through the composer.
Build and verify both the release native addon and the WebAssembly renderer so the ownership fix stays consistent across every live host.
Issue: #38
Session: ses_fa1aaf89dffezIsneAEezbytzc
Persist renderer-owned containers, element ID allocators, and window event IDs across JavaScript module evaluation. The native renderer callback can now route into the active React root after bun --hot replaces the module graph.
Bind render-level onEvent callbacks to the owning root. Stale element and window events are rejected before they can reach either React handlers or the replacement root observer.
Extend the real bun --hot child-process regression to click both before and after reload and confirm that remounted roots keep unique IDs.
Issue: #37
Session: ses_fa1aaf89dffezIsneAEezbytzc
Document element and renderer keyboard callbacks, action dispatch order, and imperative focus traversal as part of the public API contract.
Update the documentation site to Holocron 0.33.0 and refresh its lockfile. The website typecheck and lint pass with the new dependency graph.
Session: ses_fa3b8830cffeGdTgarIef6r2Kn
Remove GPUIX's process-wide Tab and Shift+Tab bindings so focused editors and terminals receive the native key events directly.
Add renderer-level onKeyDown and onKeyUp callbacks, plus focusNext and focusPrevious wrappers for applications that want to install their own traversal policy. Keep browser focus on GPUI's hidden keyboard element after Tab without turning that platform safeguard into focus traversal.
Give each mounted root a key-event generation so queued callbacks cannot cross a remount. Disable native root listeners on unmount and preserve the active root when a second root is rejected.
Update the focus documentation, release note, native declarations, and end-to-end tests for element delivery, renderer delivery, explicit traversal, remount safety, and root ownership.
Session: ses_fa3b8830cffeGdTgarIef6r2Kn
Decode base64 and percent-encoded image data URLs when the src prop changes, then retain the decoded bytes through gpui::Image while preserving filesystem path loading and image element identity.
Reuse the data URL decoder for SVG sources, document the API, and cover the native render path with a screenshot comparison against the same filesystem image. Add a release changeset that references issue #35.
Keep a TODO at the JSON boundary for replacing base64 transport with binary mutations so large image payloads do not decode during paint.
Session: ses_fa3e66794ffeXNYejd15WllDnE
Expose two-stop linear gradients through the React style.background API with typed stops, CSS angle direction, and sRGB or Oklab interpolation.
Translate the structured value through the retained style pipeline into GPUI backgrounds. Reuse the same resolution for painting, mouse occlusion, and anchored overlay fill detection so transparent gradients keep the existing interaction rules.
Add native translation and transparency tests, an end-to-end GPU screenshot test for gradient direction, public documentation, and a minor changeset for @gpuix/native and @gpuix/react.
Session: ses_fae3bda32ffe3CrFWAX0OEwcI6
Add a macOS frosted-glass dashboard that demonstrates GPUI's native blurred window backdrop, transparent titlebar, and translucent React surfaces.
Keep the root tint and glass cards low-opacity so the system vibrancy remains visible. Add a dedicated example command, document it in the examples table, and include a release changeset.
Validation:
- Type-check the example with TypeScript
- Run lintcn in examples
- Launch the native window and inspect a macOS window screenshot
Session: ses_fae3bcd26ffe4af01dEaLO6DG9
Make every native example honor GPUIX_BACKGROUND and make every current real-window automation example pass that flag. Human launches still focus normally, while agent-driven launches avoid taking the user keyboard on macOS and Windows.
Explain why live input, clicks, and screenshots do not require activation. Correct stale guidance that claimed fill and press were unavailable, and document that Linux currently ignores the focus option.
Validated with the examples and example-app test suites, type checking, lintcn, a live screenshot, and a macOS foreground-process check.
Session: ses_fb208083cffewN8NfeygDAdslz
Reduce the renderer mutation contract to one applyBatch call per React
commit across napi, wasm-bindgen, and the GPU-backed test renderer.
- replace the dynamic batching Proxy with an explicit commit-phase facade
- keep application commands on the original renderer instance
- remove direct create, append, style, text, prop, and commit entry points
- remove the unused removeChild and setCustomPropValue wire operations
- require raw JSON style and custom-prop values and boolean event flags
- regenerate native declarations and update architecture documentation
- update serialization benchmarks for the smaller protocol
- add a minor changeset for @gpuix/native and @gpuix/react
Validated with 204 Rust tests, 359 React tests, 47 example tests,
6 starter-app tests, release native and Wasm builds, lintcn, and both
serialization benchmark stages.
Session: ses_fb7d2b638ffen9PHc0FVU3DpAv
Tommy D. Rossi