Grid Changelog

Release history is tracked here beginning with 0.66.4. Earlier capabilities remain discoverable through featured guides.

Grid 0.67.0 — Upcoming (not released)

Summary

Grid 0.67.0 brings computed drawings into Views and Code, completes the current View authoring journey, and adds native validation for model-input record fields. It also incorporates the compiler tools and workspace improvements developed on the unpublished 0.66.9 milestone.

What's New

Computed drawings in Views and Code

Use Drawing, shape, Group, Graphic, Label, Overlay and Handle elements in the existing UI language. Geometry and appearance use native Grid expressions. Overlay controls retain ordinary View behavior, and handles change explicit writable point inputs through revision-guarded atomic writes. Forms stage handle changes until Save; private previews leave shared inputs unchanged.

Code's Draw workspace supports selection, placement, grouping, transforms and checked source edits. Derived expressions retain their ownership; Add transform preserves the original geometry formula. Reusable and imported elements remain linked to their source definitions. Artwork SVG exports the graphics layer; View print includes ordinary controls.

This is the initial drawing delivery. Further performance work and broader acceptance coverage are scheduled for 0.67.1; the full original graphics plan is not described as completed.

Record field validation

Declare exact VALIDATE FIELD paths on writable model-input records. Native checks validate proposed whole-record and field writes atomically. Forms show path-specific errors, and Code prepares checked field-rule edits while refusing schema changes that would leave rules behind.

Improvements

Syntax inspection now follows compiler expression definitions, reducing the risk of compiler changes being omitted from tooling. Existing syntax formats and model behavior are preserved. The parser also retains authored item boundaries and exact intervening text. Complete nested source-syntax retention remains in progress.

Completeness reporting follows the compiler's program fields, so new fields must declare whether their source structure is represented. Syntax inspection also avoids redundant copies of source text and node data, and reuses parser-owned separator information instead of repeatedly parsing source gaps.

Inspect graph paths, partitions, patterns and fixed points as nested compiler declarations, including their objectives, selectors, seeds and bounds. The AST shows the retained intent instead of internal lowering calls. New supported fields flow from the compiler definitions; source locations stay separate from field data, and transformation support remains explicitly discoverable.

Rule inspection now follows the compiler's own trigger, action, schedule and policy records. Fields link to nested structure, so compiler extensions no longer need matching handwritten rule visitors. RESET and CLEAR omit their internal placeholder values. Queries using earlier flattened rule/schedule attributes need to follow the generated fields described in the compiler-tools guide.

View and schema inspection now follows compiler records as well. Explore named View items, guards, labels, arrangement rows and schema fields through generated structure. The inspector includes a View example and follows name links for readable labels. Unclassified fragments remain visible as incomplete source.

Find elements and imported components by name or description in insertion and outline search. Selecting an outline result opens its source and Properties. Insertion follows refreshed contracts and placements, preserving equivalent drafts and clearing obsolete fields.

Inspect a generated record-form field to edit its nested source default. For a computed or referenced default, Properties explains the containing expression that owns the value. Cancel pending Properties, options, event, slot and record edits without losing drafts; late replies cannot replace a newer edit.

Drawing functions compose nested arrays through DRAW_GROUP, accept native color values, fill supported paths and geometry holes correctly, and render arc and ellipse strokes and linear gradients.

Bug Fixes

Repeated drawing rows retain keys and overlay drafts when another client changes record inputs. Native MERGE preserves stored fields when combining plain input objects with authored records.

Drawing gestures account for fitted previews, zoom and group transforms. Handle hit targets retain their screen size. Escape cancels unsent movement and pending validation, while already-dispatched writes retain their revision receipts. Successful Form Save/Discard clears obsolete handle feedback.

Saved Views load their compiled preview in Code after Save and reopen. Failed loads offer Reload preview. Print output excludes editor chrome and notices.

Compatibility and Migrations

Existing Canvas pixel configurations retain automatic normalization. New Graphic authoring defaults to unit grayscale and supports explicit unit/byte/auto ranges. Drawing paths support the absolute M/L/C/Z subset; relative commands are rejected. Native raster text returns an unsupported-operation error. Malformed drawing values produce errors instead of substituted coordinates or omitted segments. SVG values display as inert images. Valid older drawing values retain documented optional defaults; no model-source migration is required.

New drawing contracts, guarded handles and record field rules require matching native capabilities. Unsupported hosts refuse them without weakening guards. Record field rules do not extend to computed/default owners, private-local fields, array elements or resident-table rows. Spreadsheet formula export discloses that these native field contracts are not enforced there.

Known Issues

The large-drawing latency targets are not yet met or fully measured. A local development workload with 1,000 shapes and 20 overlays recorded p95 85.6 ms to a DOM update; this is not physical-paint or production-profile evidence.

Broader image/pixel/export, nested-control, older-host, source-cancellation and native capability-loss combinations, plus idle/retained-memory and historical ordinary-path measurements, remain scheduled for 0.67.1. Existing safety and validation limits remain enforced. Native GPU composition, animation timelines, shaders, advanced path editing and raster painting are outside this increment.

Documentation Updated

The shared View specification, guide, function reference, generated contracts, language registry and canonical examples describe this increment. Cloud and Dev review/import/publication work remains separately recorded. Books and Pro remain on hold. Source landing does not establish product or website publication.

Grid 0.66.9 — Upcoming (not released)

Summary

Compiler tools expose Grid expressions as immutable syntax values. Models can inspect formulas, construct source, substitute expressions without capturing variables, and request analysis or checked renames from the Rust compiler. This development milestone has working examples and has not been published.

What's New

AST.QUOTE captures an expression without evaluating it. AST.DEFINITION reflects local declarations. Traversal, constructors, rendering, and hygienic substitution operate on a versioned data format. AST.PARSE, AST.ANALYZE, AST.CHECK, and AST.RENAME use the host's compiler service. See compiler tools for supported forms and limits.

Improvements

Timed notifications now wait while you hover or focus an action, then use the remaining display time when you leave. Removed notifications no longer retain their timers.

Large Code workspaces prepare scoped source files with less repeated scanning. The full outline, scoped edits and Problems markers remain available. Opening a very large source file still needs further response work.

Long Notebooks now show one live editor at a time while keeping every block readable. Click another block or use its Edit action to move the editor there; shorter notebooks keep their direct editing layout. Unchanged blocks stay steady while you type. Notebook cards also follow the dark theme correctly. Opening a very large notebook remains an area for further work.

A continuous frame now joins Data, Code, App, Chat, and global screens. The Grid mark opens Home, a central left rail selects layers, and Help and appearance sit below. Data keeps its familiar editing tools inside the frame. Narrow windows use an anchored layer picker; desktop controls share one native titlebar. Resizing between the rail and compact picker closes an open navigation popup and returns keyboard focus to a visible control. Global screens use the same frame without reserving another empty ribbon row. The slimmer rail and top bar surround one rounded, inset workbench, with a clear active-layer marker and a quiet background behind Data's existing ribbon and grid. At phone widths, the model title has its own row above navigation and editing controls, so it remains readable beside the companion action. Back and Forward revisit layers and global screens in the current model. Open Chat beside places the existing conversation alongside Data, and Open App beside brings the model's App view alongside Code. Focus either pane to direct shared editing commands, resize the divider, or use tabs when space is narrow. App pages retain their own navigation and unfinished-work guards while Code keeps its editor. Closing Chat retains the conversation and draft; reopening restores the divider position in the current model session. Both panes remain in Live. The frame's Open beside menu also offers a Browser reference pane on Grid Desktop. It stays beside the model as you change layers, keeps page navigation separate, and never publishes reference-page data into formulas. Closing and reopening retains its address draft and resident page session; narrow tabs hide each native page independently.

Press a layer and drag through the rail to preview its purpose, then release over a destination to switch once. The stack follows your pointer; releasing on the current layer leaves your work in place. Escape or releasing outside the choices cancels. Focus a rail layer and press Alt+Down Arrow to explore with the keyboard, then Enter to accept. Reduced motion removes spatial movement. The previews are lightweight illustrations; they do not start hidden workspaces or transform live Browser content.

Data keeps its established ribbon, formatting tools, and grid layout. Clipboard reads, file drops, and paste preparation retain their original Data context and destination. Leaving that context cancels unfinished preparation; completed saves and formatting acknowledgements cannot repaint another model. Switching partitions also releases a previous cut's move behavior. Formatting-only rich paste now participates in Data Undo/Redo, including after a visit to another layer; failed saves remove the pending history step. Open definition in the Formula group follows an exact authored cell or named value into Code. Show in Data makes the return journey explicit while ordinary layer switches retain their working positions. Attach to Chat carries an exact value into an unsent question, preserving its draft and images, with an explicit return to its Data or Code origin. Reveal in App finds direct bindings in loaded declarative Views, offers a choice when several match, and highlights the accepted element. Unsupported mappings stay unavailable instead of guessing.

The Live context control can create one named private scenario beside Live for a supported portable workbook. Source, inputs, and manually advanced time belong to the copy. The shared layer and history controls follow the focused context. Compare with fixed At creation values, filter changed inputs or results, search the full comparison, and see typed differences while Live continues independently. Closing the pane hides it and retains its drafts, even while another companion is open. Live shows the retained scenario's name in its context control; choose it there to resume. Discard scenario… requires a separate confirmation. Explicitly reopen it or choose Refresh scenario to refresh private values. These experiments are ephemeral, expire after 15 idle minutes, and have no Apply to Live operation. Unsupported models are rejected; scenarios do not run external actions, jobs, connectors, Browser surfaces, JavaScript, imported View components, or AI Chat requests. Choosing a layer from Home or Help returns to Live and keeps the private copy available; Return to model restores the previous workspace context. Preparing a scenario preserves an open Live dialog and its unfinished edits. Select the ready scenario explicitly after closing the dialog. Live model actions remain unavailable while private work has focus; notifications and account controls remain accessible.

Undo and Redo stay in the shared top bar and follow the focused supported editor or surface, with tooltips identifying the editing context. They dim where history is unavailable. Visiting Home or Help preserves the open model's history; return to Data to undo or redo a cell edit. Chat composer Undo affects unsent text only when the browser exposes that history. Supported authored App views retain acknowledged Undo/Redo steps when you leave and return to the unchanged view; uncertain actions stay unavailable rather than skipping to older edits.

Five working examples cover model auditing, checked refactoring, an invoice language backed by native TREE values, and staged source generation. The Code workspace provides example scratchpads and explicit generation previews. A bounded Rust worker checks generated source and evaluates selected results in a fresh LIR model. Reviewed replacements are staged until explicitly saved. Editor help includes AST.QUOTE and dotted AST names.

Compiler-backed rename preserves untouched comments and formatting while refusing binding collisions and capture.

Select a source expression and choose Explain expression to inspect its resolved binding, contextual type, known effects, direct dependencies, and available units, bounds, and validation proofs. AST.MEANING exposes the same facts to Grid programs. Reports identify the exact source revision, refuse stale selections, and distinguish established facts from partial or unknown information.

Checked edit transactions now replace an expression, extract a function, or change a local function signature and update its resolved direct callers. Code shows focused before/after edits and resulting diagnostics, then rechecks the original draft before staging all changes together. AST.EDIT and AST.APPLY expose the same source-only workflow to Grid programs. Stale drafts, altered transactions, binding capture, and unsupported call uses are refused. Compilation checks validity and does not claim equivalent behavior.

Grid-authored analyzers inspect model source as data and return findings in Code’s Problems list and editor markers. Suggested fixes open a checked edit preview and require explicit staging and Save. Revisions, source locations, report sizes and suggested operations are validated; findings do not claim compiler validity or equivalent behavior. The included effects analyzer provides a reusable starting point.

Substitution now protects names across generated functions and modules, including forward and recursive references. Inserted expressions stay free of accidental capture by generated declarations, parameters, or local bindings. Incomplete or annotated source forms remain explicit refusals; existing source uses checked edits. The refactoring example demonstrates module generation.

Quoted templates now support named expression holes and argument or array list splices. Inspect expansion shows generated code beside retained template and input locations, explains renamed bindings, and follows compiler findings back to their origins. Inspection checks generated declarations without executing them. The new quoted-template example also works with the existing reviewed generation flow.

Bulk syntax tools select matching nodes and replace independent occurrences without repeatedly validating the entire tree for each lookup. Operation discovery explains whether a selected node supports rendering or lexical substitution before a tool attempts it. The checked-refactoring example now demonstrates these operations alongside rename and hygienic substitution.

The syntax inspector now exposes rule trigger policies and action targets, assignment schedules, solve goals, structured function signatures, graph and predicate schemas, and View outlines. It distinguishes complete inspection from safe source emission, and explicitly identifies clauses that still retain only source. Comments and formatting remain available in the exact authored text.

Bug Fixes

Network opens large machine lists faster. Find machines searches every peer by name, route, or status, and page controls keep all matches reachable. Refresh retains the current page where possible; speed tests retain all eligible routes.

App authoring avoids replaying its initial document and renders large outlines as you scroll, reducing opening and return-from-Preview work. Keyboard navigation, range selection and nested collapse reach the full outline, including in narrow Elements drawers. The canvas, recovered drafts and Undo/Redo remain available.

Code's Problems panel opens and closes large diagnostic lists faster, with continuous scrolling, keyboard access to every located problem and fix action, and retained focus and text selection. Editor markers keep the complete set of current diagnostics.

Dataset's preview-and-steps editor opens large results in pages of 20, with direct page navigation and access beyond the previous 200-row preview limit. Editing source names or output targets avoids rebuilding unchanged rows and type hints. CSV and Publish continue to use the full prepared result. For very large results, the first page appears while exact full-result column type hints finish checking in the background.

Shared tooltips now stay inside the window and cancel pending hints on Escape, scroll, or resize. Menus retain keyboard position during command updates, scroll without closing, and return focus before opening another dialog. Workspace buttons acknowledge hover and keyboard focus immediately, with reduced-motion support.

Command and model search now open the exact chosen result, retain selection through refreshed lists, respect input-method composition, and transfer keyboard focus reliably into the next dialog. Search fields expose their active result to assistive technology. Narrow windows retain equal gutters and keep keyboard selection visible; indexed search avoids repeating normalization while typing.

Home search avoids redrawing an unchanged model library when the picker opens or closes. Model previews retain their appearance with less rendering work in large libraries and search results.

Large Home libraries now render the visible rows and cards as you scroll, preserving rename drafts, pending actions, and keyboard traversal. Switching layouts keeps your place, and the toolbar fits narrow windows.

Chat prepares and displays focused source changes in large models faster, preserving exact line alignment, review context, and stale-source checks. Long Chat and side-rail conversations open at the latest messages, with older messages available in small groups. Revealed source reviews, text selection, and message actions stay in place as the conversation continues.

App builder outlines now support anchored range selection, separate selection and keyboard focus, parent/child navigation, and expand/collapse controls. Bulk actions use the same selection as the canvas. Context menus fit all window edges, retain focused commands, and let users scroll long lists. Menu dismissal preserves the intended grid selection without overriding a newer gesture.

Source-reflection formula edits now refuse both cell and range splicing, so the host can refresh reflected source through ordinary compilation.

Large Code files now open with less source navigation work while retaining the complete outline, source links and diagnostic markers. Dense initial opening still exceeds the local response target.

Compatibility and Migrations

Existing ARGS, BODY, and FUNCTION remain compatible. Bare embedded LIR runtimes must explicitly install the compiler service for compiler requests. Ordinary syntax data functions do not need that service.

Known Issues

Source-module syntax projection is incomplete and reports that explicitly. Rendering refuses declarations with unsupported modifiers and qualified references; use retained source or checked rename for those forms. Generation uses explicit reviewed authoring actions; automatic macro expansion is not provided. Range-source-edit and complete generation costs have local measurements. Worst-case latency remains inconclusive: identical-binary controls also fail the unchanged tail budgets on this shared workstation. No optimized-profile or zero-latency-regression claim is made.

Documentation Updated

• Compiler tools and syntax values
• Language feature matrix
• Function reference
• Model interface layers

Grid 0.66.8 — 2026-09-26

Summary

First published September 26, 2026. Grid 0.66.8 is available for macOS Apple silicon, Windows and the Linux server, as recorded in the release ledger.

This release includes the Code, Data, App, Chat, document, Deck and runtime improvements developed during the unreleased 0.66.7 milestone. Version 0.66.7 was closed without publication. AI Surface Suite integration is in progress; its canonical Process visual authoring and workbench adapters remain unfinished.

Grid Views brings interactive view declarations into model source, with pages, local state, reusable elements, model actions, layouts, and presentation choices. Code understands the View vocabulary and checks embedded JavaScript and CSS. Named local SCRIPT helpers are checked at each property or callback use with a known contract; type errors point to the helper reference in Grid. Imported native event signatures now provide member checks and completion inside JavaScript handlers, with declared event values captured for each callback. Kanban, Calendar and Map also expose typed event values and known row-field completion. Typing card. in a Grid handler offers its known fields; choosing a name containing spaces inserts the correct bracket syntax. Suggestions respect local parameters and shared component uses. Imported event contracts also supply nested-record and array-item suggestions in Grid expressions. Grid event handlers mark missing known-row fields and invalid scalar field reads. Calendar end-column settings work on their own indented line. View scripts can now use JSX for component-valued helpers, with Code diagnostics, preview loading and prepared packaged/framework exports. React comes from the renderer. Native contracts can select JSX adapters with declared properties, lens pairs, events and slots. Adapters retain refs through updates and can place declared style parts on their markup. Code completes lens/part names and marks invalid event calls at their source. Component imports use locked libraries; Code also completes and checks native props described by those contracts, with isolated types for each View. Full package declarations remain incomplete. The remaining View features are still being completed. Numeric selections can be cleared, conflicted selections retain your value for reapplication, and successful Form submissions discard their field drafts.

Code now extends draft feedback to local scopes and keeps independent problems visible when a named-function call has an argument or type error. Bounded iteration can stop on a convergence predicate and report why it finished, while pure helpers can accept callable parameters and invoke local lambdas.

Use color snapshots from camera and video connectors with the same AI setup as Chat and workbook functions.

What's New

Human editorial review and run limits

Draft a document with an agent, give feedback as its human editor, and accept, revise or decline through Processes. The walkthrough retains the decision and iteration limit explicitly; it does not publish the draft. Start now offers model-call and time limits, including time waiting for people. Waiting and completed runs show actual model-call, participant-turn and operation counts.

See the human-review guide.

Choose a workflow method

Bind a Boolean choice between two authored procedures, then RUN the selected method. Reusable processes can select their statically supplied procedures this way. Both alternatives are checked before Start, and only the chosen child runs. The brief-or-reviewed answer walkthrough shows the source and Desktop controls. Broader process-reference forms remain in progress.

• Run one View CHECK, retry failed checks, or cancel a run from Code. Progress and completed results appear while checks run in separate private copies, with direct links to failures and cleanup before another run.

• Repeated buttons and native-control events now retain their sibling ELSE handlers. Rejected changes keep their state and run the row's refusal actions; Code event edits keep the handler together without consuming neighboring content.

• Rename a Grid View page from Properties. Code updates declarative navigation and CHECK references in one Undo step, preserves its title and URL, and offers Whole model access for links across Views. Conflicting destinations and uneditable shared or imported references are refused with an explanation.

• New Grid View and reviewed App conversions each add source as one Undo step in the rich Code editor. Whole model stays open with the new View's inspector, preserving earlier history. Undo or redo the addition, then Save when ready. Cancel a conversion while Code loads; changed source or App revisions require a fresh review, and refused insertions never retry automatically.

• App-to-Code conversion now assigns usable declaration names to library components with spaces, reserved words or conflicting names. Component mapping shows original names and IDs, generated names and unsupported templates; Show source selects the complete declaration. Exported packages use the current Code name.

• App conversion retains node IDs, library records, workbench references and saved View placements. Dirty Forms inside a saved View protect parent navigation. Portable component round-trips preserve template identity without accumulating wrapper containers.

• Source component packages now carry closed local and imported Grid function dependencies. Imports rename their private helpers together, and native checks reject captured model state, authority and receiving-name conflicts.

• Export reusable components with their local element and named action helpers. Helpers travel as private nested source, including transitive dependencies, custom controls and action callbacks passed to local elements. Code and App Builder list them during import review. Receiving-model helpers stay separate, and each instance recompiles its own local state and actions.

• Review page names, routes, starting page and changed order when converting an App to Code. Show source selects the generated page. Navigation uses the same distinct names as the pages, including colliding or renamed App IDs; duplicate routes and remaining document differences stay visible.

• Import a .gridcomponent directly into App Builder with Import View component…. Choose model bindings, review the new View’s source, then Save and insert. Failed App saves retain the placement for recovery; App Undo keeps the reusable View in Code.

• Place a saved Code View inside an App with Insert View…. Review its bindings, choose its starting page, and run it in Preview. Placements keep their own local state, follow saved source updates, and protect unsaved Form edits. Added model bindings require a fresh review. React Eject to Component also preserves these placements, their App pages/theme, and nested unsaved-edit protection. Svelte/Vue/Solid downloads and published Apps can also carry captured Views and their static scripts; re-export to include later View source changes.

• Create a bound View directly when importing a source component in Code. Choose its name and model bindings, review the generated source, and add the element and View together as one Undo step before Save.

• Share stateful reusable elements between models through Code’s .gridcomponent source packages. Review source and parameter types, import into a draft, and Save to compile separate local state and actions for each instance. App Builder continues to use portable .gridui templates; shared helpers use Grid libraries.

• Reusable App components retain their library version, descriptions, parameter labels/defaults and slot labels when imported into Code and exported again. The export dialog starts with retained types and reviews those details. Grid arguments remain explicit; stale metadata requires repair before export.

• Import reusable App components directly into Code: choose a package and source name, review the generated element, then add it to the draft with Undo. The compiler checks names and supported content; Save applies the draft.

• Failed calculations in Code previews now link to their authored expressions and offer explicit value inspection. Problems shows the same source location. Native errors display their message, and known generated names become readable expressions. Private-copy failures retain separate source recovery.

• Select a View element in Inspect to open its accepted model values and explicit Why trace. Generated targets and dependencies show authored expressions and source lines; stale or ambiguous locations are withheld. Private-copy and unsaved Form values remain separate from live-model inspection.

• Conditional record defaults and selected/sorted row lists now retain matching field tags. Generated Forms keep currency, percentage and date controls; table date formatting retains its temporal carrier even after plain JSON replacement. Conflicting tags remain unset. Explicit Code column formats still override inherited policies, and removing an override restores inheritance.

• Native Form saves now check validation against all submitted values together, including computed bounds and defaults restored by clears. A rejected batch preserves every live input. The check uses the existing native evaluator on a detached snapshot. Missing/error operands, external work and unsupported snapshot capabilities refuse without committing. Forms offer Check values, retain rejected drafts and show native field messages. Save rechecks the batch. Private preview copies validate their own inputs; packaged Views require write permission for each checked input. Old hosts refuse instead of silently saving.

• Model text validation and text/Boolean equality now reach View controls with their declared messages. Invalid drafts are retained, related Form inputs validate together, and field messages and Save availability refresh when a dependency changes. Code edits the owning rule through the existing checked source transaction and Undo. Current hosts check computed operands and numeric/structured equality through the native proposed-input operation.

• Render View-local collections with direct stored-field keys, nested row lists and literal arrays. Lists update, page and print through the shared renderer; empty arrays show their empty sentence. Stable keys retain row Form drafts across reordering, and Properties edits row identity with source checks and Undo. Explicit JavaScript can prepare browser row data; invalid results show a source-bound error. Known local arrays support keyed inline editing, including tables inside keyed parent rows and reusable elements. Changes follow current parent and child keys through reorder, preserve neighboring data, and retain conflicting drafts for reapplication. Whole-local validation, reset, paging, formatting and nested table column Properties use the existing paths. Computed owners and nested model rows remain outside this private operation.

• Edit lists stored inside model records, such as Order.shipping.lines. Keyed scalar and record/list changes preserve current parent fields and other rows. Code edits the column source and the containing input's whole-value validation, with separate row-source and declaration navigation. Tables inside keyed model rows and shared elements also support scalar/record edits, preserving native types and current parent data. Missing or duplicate parent/row keys reject the write, and reordered parents retain drafts. Shared definitions expose checked column controls. Calculated owners remain outside this contract.

• Edit private table record/list fields as JSON with explicit Save/Cancel and conflict review. Blank fields keep their declared editor, sorting retains row identity, and writes preserve neighboring fields. Pair lists retain their shape. Print shows JSON values and whole-local validation still applies. Model input/default record lists also support these edits, preserving native types, exact/date text and matrix axes through the existing model action. Retained type details and conflicts expose hidden type changes. Unsupported native carriers and individual field contracts remain outside this editor; full native-host acceptance remains pending.

• Each keyed row now owns locals declared in its reusable components or directly in its body. Drafts survive reordering, paging and temporary removal, with independent inputs, actions, validation and reset. Nested rows remain separate; duplicate or missing keys explain the problem instead of combining state. Properties edits the shared declaration and preserves same-named outer locals.

• Enter mixed fractions and paste accounting, scientific or scaled numeric text into inputs and editable columns. Native format sections supply the sign, locale and units. Untouched values retain their precision; invalid or ambiguous text keeps the draft, and Forms wait for a repaired value before Save.

• Inspect validation from nested private tables and repeaters. Properties links stored row paths to the exact containing local and explains that its rule covers the whole local. Read-only lists and repeated body locals retain this source navigation and Code Undo behavior. Direct table columns no longer appear as undefined model names when their schema is known only at runtime. Individual field contracts remain outstanding.

• Table columns, row actions, pickers and repeated controls now expose the whole row source's validation contract and source navigation in Properties. Pickers distinguish their selected-value contract from their rows. Checked edits follow admitted aliases or View locals and share Code Undo; computed/native sources without a direct owner retain an explanation and navigation to Code. This does not add individual row or field validation.

• Inline table editing now follows plain aliases to their owning input/default or native table, including qualified cell addresses. Edits retain the model's atomic rule path. A local with the same name cannot accidentally redirect a model row edit. Editable fields retain headings, formats, widths and alignment through Code and Properties. Native numeric formats preserve precision and display units. Failed saves keep drafts for retry; changed row values require explicit reapplication, and sorting keeps drafts with their keyed row.

• Preview scalar and table-column patterns with Grid’s native formatter, including percentages, decimal places, negative sections and dates. Scalar displays honor host-resolved format policies, explicit control choices and View-local patterns. Sorting and editing retain original values. Numeric inputs honor host/declared patterns, show an unrounded editing value, and preserve values on untouched blur. Native plans supply decimal precision, locale and display-unit scaling; active drafts keep their units through format changes. Native entry plans also support fractions and decorated numeric paste across sections. Tables inherit model FORMAT policies from retained field tags, including reactive patterns and explicit column overrides. Policy changes preserve active editing units, and exact numeric strings retain their digits. Native-table semantic schema and declared local field tags supply the same policies; mixed/computed local field hints remain incomplete. Failed formatting offers retry; print and capture wait for the displayed formats or explain what needs attention.

• Declare interactive Views with inferred controls, pages, local state, and model-owned actions. Arrange named regions and choose controls with PRESENT.

• Reuse local or imported elements, including explicitly installed and pinned React libraries. Unsupported native contracts produce coverage reports.

• Export through the shared renderer, select a styling kit, or capture the current page as static HTML.

• Export reusable ELEMENTs from Code as .gridui App components. Choose concrete parameter types, prepare and review, then import into another App and bind its parameters. Named content slots and their defaults survive the round trip; Code offers checked add/update/remove controls and slot-name completion. Unsupported state or captured model bindings receive an explanation; source changes cancel pending exports and discard prepared downloads.

• Run declared CHECKs in private native model copies. Migrate an existing App to candidate View source with listed translation and comparison differences.

• Wrap or lift availability groups containing declarations through checked source review with Apply/Cancel. Condition-only changes stay direct; invalid references and duplicate names are refused.

• Review moves across repeater, page or declaration scopes before applying their exact source changes. Cancel keeps the draft; Apply shares Code Undo and refuses a changed draft or editor. Invalid references still prevent the move.

• Edit supported element properties from the source outline or preview selection. Each change preserves surrounding source and becomes one editor undo step.

• Edit shared options on custom automatic controls, or pin a caller-visible component to open its arguments and native properties. Labels, bindings, conditions and model access remain intact; library-private components explain their editing boundary. Closed composite calls accept shared layout phrases.

• Follow plain aliases and component arguments to input validation. Select a component's local contract and edit its shared definition with source navigation and Undo; individual instances keep separate state. Nested and transitive helper locals, including consumed caller content and native slots, expose their exact declarations. Unused helpers stay out of the selector; imported locals remain in their library source.

• Edit automatic table and map options without losing data bindings, columns, filters or paging. Table columns named like settings remain columns. Generated record forms expose shared options while keeping their fields and Save action; their schema stays with the owning input or local declaration.

• Select nested record fields and edit their source defaults with Code Undo. Plain aliases point to the input; component defaults remain shared definitions. Add, rename and remove fields or nested records in Properties, preserving surrounding comments and other defaults with one Undo step. Renaming changes stored keys; references elsewhere retain their spelling. Sensitive defaults stay in Code. Whole-record validation remains distinct from field rules.

• Edit table and picker columns from Properties: values, headings, presentation, ordering and keyed inline editing. Keep attached comments, row actions, filters and paging through checked source transactions. The panel explains implicit all-field display and the remaining field-validation editing boundary.

• Create row buttons and edit their captions, inline actions and requirements. Move or remove the full action, including nested steps and refusal handlers. Existing action keys remain intact; new buttons can have a stable key.

• Edit availability conditions and explanations together. Ordinary and direct native arrows have Action requirements controls, separate from component availability and with the selected native event's values listed. Add another requirement or remove one while keeping nested actions and refusal handlers. Named native and embedded handlers also have separate requirements sections, preserving each event's scope, neighboring handlers and slots. Each checked change shares Code's Undo history.

• Wrap controls or containers in an availability group. Edit its condition and explanation or page/View redirect together. Remove the wrapper while retaining contents, comments, multiline payloads and separate visibility. Inline regions expand in the same Undo step; declaration scope changes stay in Code.

• Edit reusable Grid elements’ arguments and shared options together, including availability. Bare calls gain parentheses when needed; caller content, imported definitions and remaining properties retain their meaning in one Undo step.

• Reorder, remove and copy pages with flat or nested content. Shared declarations between page headers remain once in source, with comments and payloads intact.

• Edit inline region contents in the inspector. Structural and native event/slot changes expand only the affected region, preserving conditions, comments and multiline payloads in one Undo step.

• Resize the View preview without losing form drafts. Navigate pages within the preview, with an explicit live mode for controls and route parameters that can change the model.

• Inspect draft elements in a private preview without discarding its state. Inspect copy pauses controls and opens source and Properties; resuming uses the same copy, including for Views that have never been saved.

• Assign a stable key to an existing table row action from Properties. Caption changes then retain its identity; nested requirements and refusal handlers stay intact, and the source change shares Code Undo.

• Preview new, unsaved Views in a private copy before their first Save, including Views converted from Apps. Live interaction becomes available after Save and requires an explicit mode selection.

• Stage input and local-state batches, restore defaults, advance native rule time manually and try supported actions in a private model copy. Reset discards the experiment; unsupported hosts and external actions report their limits. Computed button cells use guarded native touches in copies and CHECK runs, and named button targets now work in the live workbench.

• See host tool support, trust restrictions, required capabilities and unresolved dependencies beside the View. Inspect exact library locks, open Dependencies or Connections, refresh analysis and retry the preview without editing source. Failed checks and private-copy preparation offer source navigation and explicit recovery controls outside the disabled preview. Host authentication/access refusals retain their structured status. New runs and changed source/model environments discard older results; switching model, partition or environment returns the preview to Inspect.

• Diagnose observed script, library-loading and component failures beside the preview, with declaring-line navigation and bounded argument descriptions. Private drafts have their own source markers. Reports cannot mix between models, editors or preview copies; reset/reload rejects late errors from closed attempts. Sensitive locals redact messages and arguments. Rendering an error notice does not repeatedly retry the failing component.

• Check local bindings in declaration order and distinguish them from model names.

• See located errors for malformed binding lists and non-name binding targets.

• Keep unrelated missing-name diagnostics alongside named-function argument-count and type errors, including under strictness directives.

• Prefer the innermost supported scope when completing local names.

• Stop bounded iterations at the first satisfying state, including the initial state, and distinguish convergence from exhausting the bound.

• Pass pure callable helpers into named functions and lambdas, and invoke locally bound lambdas in LET and DO expressions.

• Choose Images for AI in Camera and video. Your current workbook stays open; attach the latest frame from Chat → Add source → Connected sources.

• Slow delivery keeps only the newest pending frame. Failures stop capture with a visible error; completed recordings do not restart automatically.

• Source identity, image hashes and arrival times stay with each attachment. Unknown capture times are not inferred, so this output supports snapshots.

• Choose Images and documents in local model setup to find a compatible image model. Details and installed models show whether their package accepts text or images. Chat’s image attachments link directly to this setup.

Independent reporting workflows

Use INDEPENDENTLY EACH to run a reporting process with fresh conversations for each assignment and pass the ordered reports to an editor. Desktop exposes the same authoring, model selection, Start and result inspection controls. The compiler rejects outer conversation sharing, carries, borrowed rooms and transitive external operations in these groups. Current scheduling is serial, with a 32-item ceiling; population generation and partial joins remain future work.

Improvements

System (formerly Monitoring) and Network now sit behind Advanced, beneath Code in the layer picker and in the global menu, keeping everyday workspaces more prominent. The Grid mark opens Home; Help sits at the far right with the appearance control and Advanced menu. An open model has its own return button, and the Data ribbon keeps its labeled commands.

• Repeated price edits in large lookup-driven ledgers reuse calculations for identical formulas while preserving exact changed-cell counts and samples. They also avoid rebuilding identical change notifications after checking the new values. The initial edit prepares this sharing; unsupported edits use the existing evaluator.

Process conversations now show completed replies while later turns are running. Follow a debate from the Processes panel, browse earlier turns, and cancel while keeping accepted replies visible. Late replies are marked unaccepted. This is turn-by-turn progress, not token streaming.

Completion prefers the innermost supported scope, including local bindings.

The image producer retains one newest pending frame when delivery is slow. Source errors stop capture and appear beside the connector controls. Connected sources shows stopped captures clearly, preserves your draft when a read is cancelled, and offers an Open Connectors shortcut for first-time setup. Choosing a model keeps your question and attachments. Open Grid Agent returns to Chat from any workbook layer.

Bug Fixes

• Legacy imports of the shipped politics, social-science and governance .grid modules work alongside their canonical .gs paths.
• App-to-View migration now chooses property aliases and writes metadata consistently across builds, including the default Badge style.
• Agent tool receipts now keep the same hash across builds when JSON object keys arrive in a different order.
• Choosing a worksheet after an Excel import now keeps that choice when later workbook updates arrive.
• Code analysis handles deeply nested expressions without overflowing its thread stack while checking callable types.
• Predicate facts can use room as a subject without being mistaken for a shared-room declaration.
• Repeated Views and App controls now keep labels, validation messages, tabs and page headings attached to their own instance. Control associations remain stable through value updates and keyed row reordering. Named-function semantic errors no longer suppress independent missing-name checks. Interval rules using SKIP MISSED now tolerate a tick just after the current deadline, preserving the schedule's phase while continuing to skip missed intervals. Previously, ordinary clock jitter could prevent these rules from firing.

Source fields are read-only when starting an existing workbook's declared connector, so editable controls no longer suggest that ignored changes apply.

Compatibility and Migrations

Code checks use the current draft without applying it. No migration is required. Plain ITERATE keeps its mandatory integer bound of at most one million steps. The new exit predicate is pure, and Tensor-resident iteration rejects UNTIL with a named diagnostic. Callable parameters require statically inferred function types; any cannot be invoked as a callable. Callables cannot be stored in cells, state, collections, or choice fields. Named recursion remains outside this change.

Requires Grid 0.66.8 Desktop Pro and the installed FFmpeg decoder. Asking about an image requires a vision-capable model. This adds neither audio/native video understanding nor recording storage, and does not publish additional model packages. Camera permissions and platform-specific device support still apply.

Known Issues

Syntax failures, external bindings, and unsupported scopes retain conservative limits. This change does not add general builtin argument validation, broader rename, or predictive AI suggestions.

Focused callable, bounded-iteration and scheduler regressions passed. Their scope and local cost measurements cover selected development scenarios; complete platform validation remains outstanding. Autonomous timer rules require the default in-process host residency; deployment solely into the optional process calculation pool does not activate timer rules.

These connector images do not carry original capture timestamps, so they cannot use timestamp-checked live observation or historical date queries. Physical camera permissions and packaged Windows/Linux behavior remain to be exercised.

Grid Views implementation is in progress. Its remaining features and validation remain unfinished.

TEAM and PROCESS declarations now compile into an inert, validated process artifact inside the compiled model. Desktop now selects the sequential runtime: save a team and process, choose its models in Agent → Tasks → Processes, and press Start process. Ordered, attributed replies and the final result are inspectable in the panel. The guided debate uses two speakers and a chair in one shared room. Other product packages do not enable the capability by default. Ordinary formulas, unaddressed ASK and the existing agent task API keep their current behavior. Internal compiler replay can reproduce the artifact from captured source and imports without consulting changed live libraries; this does not enable Start or provide durable process recovery. Libraries can be imported under multiple aliases while retaining separate team, process and captured-value namespaces in the internal artifact. Internal local turns now use bounded model I/O, share the existing agent model slot for each turn and preserve prepared conversation bytes. Queued cancellation and deadlines release their resources without stopping unrelated I/O. Internal HTTP Start now verifies installed signed local models outside the host lock, with frozen inputs, bounded I/O and one unchanged admission/execution deadline. Refused admission releases its resources; accepted retries keep their original run identity. This remains an internal verification capability. The internal operation runtime now records an attempt before invoking an adapter, retains uncertain outcomes across recovery, and keeps results until the process acknowledges them. Compiler resolvers can now provide exact installed ops: type packages: aliases share package-qualified identities, source-created types work through child workflows, and owner-only types can be matched without allowing source construction. Source replay freezes the imported metadata. Internal operation metadata now pins the adapter, owner, policies and execution limits under a distinct callable route. The owner rejects changed bindings and expanded limits before dispatch. Installed sequential operation exports now compile as typed PROCESS steps, including unbound calls and calls inside imported processes. Their descriptors survive saved-source replay and compiled-model save/load. A selected internal volatile environment now executes these calls through the operation owner, retaining typed results and acknowledging receipts only after process acceptance. Pending work suspends without polling or repeating dispatch; accepted results can feed agent context and ordinary calculations. The internal process service now starts these mixed workflows, binds authority for the caller and model, exposes pending work, and queues explicit settlement on its existing executor. Duplicate or stale settlement requests cannot spend another lookup or act on a later step. Cancellation preserves late results without accepting them. Combined durable recovery, product catalogue installation and API/browser adapters remain unfinished. Ordinary Start refuses operation calls without the selected environment. The alternating debate and draft/review/revise language examples now execute in that internal harness. They exercise reciprocal replies, chair guidance, fresh reviews, explicit child context and honest stopping results. Published named inputs retain proven source types without evaluating their values at Start, and ordinary Grid arrays keep their existing shape when crossing that boundary. Code also highlights the coordination vocabulary and offers scoped process completion, distinguishing data, participants, child targets and teams. Suggestions preserve statement order, loop scope and independent-group visibility. This does not enable product Start or process rename. The shared host log now supports bounded streaming recovery for the forthcoming durable process owner, preserving existing recovery-log compatibility. Durable process execution remains under implementation. Internal process and conversation updates now validate together before either advances, preventing a stale or mismatched context from partially accepting a turn or disclosure. This does not enable durable recovery or product Start. Internal execution now retains explicit loop, child and turn continuations, preparing for durable recovery while preserving existing language behavior. Internal checkpoint groundwork now preserves core values with bounded decoding; complete durable process recovery remains unfinished. Ordinary SUM also retains its numeric result contract in shared function inference and internal process kernels.

Internal process hosts can retain Start identities and results across restart. An explicitly selected recovery mode now resumes safe core workflows from their accepted turns, preserving provider history, shared context, captured inputs and the original deadline without repeating accepted inference. Uncertain calls remain unresolved, and cancellation survives restart. Returned answers also survive interruption before acceptance: resume validates the saved answer without calling the model again. Wider effect recovery and product Start remain unfinished.

Documentation Updated

• Grid Views: source authoring, layouts, exports, and explicit CHECK tooling.
• Native libraries: installed-package derivation and exact runtime pins.
• Interface layers: local scope diagnostics, semantic error coverage, and completion limits.
• Core concepts: the total expression core, bounded work, reactive shell, and tracked effects.
• Collections: early exits, completion reports, and the unchanged step ceiling.
• Named functions: callable parameters, local helpers, and compile-time safety constraints.
• Rules and schedules: timer residency and the distinction from Live Model table status.

The image input guide, AI setup guide and walkthrough, and canonical Camera images for AI example describe the new flows. Shared release history records the publication of 0.66.8 and earlier releases, while preserving unreleased milestones as historical entries.

Internal process development now supports typed human review steps. A human question pauses the process without holding an execution worker; an authorized reply continues the same process, and invalid input leaves the question open. Retries, cancellation and the original deadline are handled explicitly. This supports volatile runs and selected local recovery: questions survive restart, accepted replies are not requested twice, and duplicate submissions retain their original receipts. Explicit resume and the original deadline still apply. The selected internal app now provides a Processes panel for starting, inspecting, resuming and cancelling compiled workflows, discovering assigned questions after reload, and submitting typed human replies. Provider credentials stay on the server. Desktop selects the sequential runtime; media display remains unfinished.

Internal coordination development now has a shared type foundation for generic operation results: schemas preserve family identity and payload types, and can restrict construction to an owning service. Compiler inference retains those identities and payload relationships through function signatures and type lowering. Generic CHOICE declarations now retain checked type parameters and recursive schema metadata through compiled artifact save/load. Inferred constructors and constructor-pattern MATCH now execute through the shared evaluator, including values passed through functions, immutable named/cell bindings and recursive fields. Explicit family applications such as Maybe<number>.None() now work in values and patterns, retain their static contracts through save/load, and format as authored language. Internal process storage can now preserve nested source-created CHOICE values with exact schema identities and bounded decoding. Typed storage entrypoints also enforce the retained payload contract, including recursive generic fields. Source-created values now pass through typed workflow inputs, child processes and results, with readable inspection and restored arguments on recovery. Owner-issued operation results remain unfinished; this does not complete the AI coordination extension.

Internal coordination development now includes a shared-room owner for ordered conversation, history boundaries and material withdrawal. Public turn and process state changes can commit together, and uncertain calls retain their ownership. Fresh sequential room plans now run through Desktop's Processes panel.

Internal process development now executes PRIVATELY blocks through the existing native runner, including continuing histories, typed human suspension and recovery. Block-local names stay local and returned summaries have their own material identity. Room declarations and IN destinations now retain their source meaning through parsing, imports and formatting. Sequential public turns see prior accepted speakers; public sharing and withdrawal affect subsequent packets. Child processes explicitly borrow room members by role key. Accepted-turn receipt replay rebuilds the public transcript without repeating inference. Existing room handles, live inspection during model execution and independently durable room hosting remain unfinished. The internal runner now executes READ(room) to capture public room metadata, including messages, withdrawals and turn outcomes. Grid collection expressions can query the result. Reads perform no inference and reject oversized snapshots without truncating them; private histories and message bodies are excluded.

The selected internal Processes panel now displays room participants, message references, withdrawals and turn outcomes. Waiting, completed and failed runs can expose room metadata without an authored read. Final metadata survives record recovery; unavailable or oversized inspections carry explicit reasons. The panel also displays retained, ordered replies for the Desktop sequential subset. This does not complete API-operation adapters or the wider coordination language.

Combine an API read with an agent

Desktop processes can import an installed API package through ops:, call a single GET/HEAD query, share its checked result with an agent and return the combined data. The walkthrough includes the source and example OpenAPI definition. The adapter uses existing network policy and model credentials, with one bounded attempt and no implicit retries. Commands, pagination and recovery across host restart remain outside this slice.

Review a collection with a process

Use EACH chapter IN chapters for ordered agent reviews, or add WITH summary = "" for a running summary. Sequential turns keep conversation history; empty collections make no calls. The guide includes a runnable Desktop example and the current 32-item limit. Generated populations remain planned; independent fresh-child reporting is covered in the newsroom guide.

Preserve built-in calls in existing helpers

Data parameters such as value and index no longer hide VALUE(...) and INDEX(...). Local helpers already inferred as functions still take precedence. Ambiguous built-in-name parameters retain the built-in interpretation; use a distinct callback name when passing a function. Calls through named helpers or captured local functions retain their effects during callback checks. See named functions.

Grid 0.66.7 — Not released (superseded)

Summary

Grid 0.66.7 was not released. On September 25, 2026, the planned release was superseded by 0.66.8. This record preserves the development work; it does not claim published installers, an updater release, or completed full validation. Its user-facing changes carry forward for review in 0.66.8.

Code, Data, App, and Chat offer four ways to work with the same model. This development version builds on 0.66.6, including its shared desktop runtime, independent workbench windows, and source-conflict protections.

What's New

• App and Chat share the same unfinished question, including line breaks. Moving into Chat carries the current view and selected value, with a direct return. Documents combine writing and view commands in one set of tools. Same-model links show readable destination labels, and Back leaves a presentation's first slide for the preceding view at its retained reading position.

• App layouts start with a clear empty canvas and offer Add value, Add note, keyboard arrangement, collision-aware dragging, and Undo. Live values keep model formatting, narrow reading views stack cleanly, and Done waits for saves.

• App presentations fit the whole slide, offer a clear slide outline and Back/Forward history, and group editing and exports in View actions. Live presenter assumptions share formatted, acknowledged controls. Done waits for saved slide edits, including an immediate Undo.

• Read structured answers in App and Chat, with headings, lists, tables, and code. Compact assistance retains the preceding exchange while you ask a follow-up. Preview an excerpt's formatting before keeping it in a report; opening the destination now accepts its saved revision before insertion. Document slash commands accept full titles such as /heading 2.

• Enter percentages naturally in App and notebook controls: 6 means 6%, while the model retains 0.06. Formatted inputs preserve incomplete edits, failures, and existing unit tags; read-only model values are identified explicitly. Live document and notebook references retain model display formatting. Charts and Visuals open with one heading and their editing tools in View actions.

• Add images, a camera/window capture, video frames, selected image inputs, or earlier conversation attachments through one Add source picker. Reused observations retain their source and original timestamps. Narrow layouts keep the picker controls reachable while you browse.

• Use the same saved AI connection for Chat, Agent, and new workbook AI requests. Choose OpenAI, Claude, Vercel AI Gateway, your model server, or an installed local model. The runtime restores that choice after restarting; formulas with explicit model releases keep their own selections.

• Connect an existing model server from AI setup: enter its API address, discover models, and save your choice with an optional key. Grid remembers the connection for Chat and Agent, and keeps server credentials separate from hosted providers.

• Manage agent tasks from Chat with saved profiles, provider choices per task, shared call limits, cancellation and a draft–review–revise team. Review source proposals before applying them. Use AI setup shares the saved provider, installed model or model-server connection without another configuration. Attach images to a task or share them explicitly across its review team. Supported Unix hosts can retain images in recovery records; uncertain remote attempts are never retried automatically. This implementation still needs packaged/live-provider QA before a release claim.

• Deck adds structured model-connected presentations across App, Code, Data, and Chat. Use live scenario controls or a frozen presentation capture, share a render-only audience window, and export editable PowerPoint or print slides. Notes are private by default. See Deck presentations.

• Prepare Registry publications from Code for Libraries, Templates, Solutions, and pretrained Models. Select an artifact and existing signing key explicitly, run the CLI's local validation/signing dry-run, and inspect its exact receipt. Preparation runs as a native job with output, Stop, and session recovery while navigating Code. Signed publication bytes are retained locally; reopen and verify them after restarting, independently of later source edits or the signing key. Review a Registry destination and explicitly selected publisher credential to submit those exact bytes. Stop local work, refresh remote status, and recover saved submission state after restart without silently retrying. Enroll a publisher from an existing signing key, recover a lost enrollment response, and select its approved credential for publication. Browse all four artifact kinds in the configured Registry, inspect catalog metadata, copy exact coordinates and open their Registry pages. Reviewed Libraries and pretrained Models open directly in installation review with the exact version and Registry preserved. Templates and Solutions now offer source installation into a new folder, with native job output, Stop and recovery of the latest saved installation. Inspect installed source files and a Solution’s declared models and dependencies without evaluating or activating them.

• Create extension projects in Code using any of the ten CLI language profiles, choose a new folder, follow creation output and open the generated source. Creation supports Stop and recovery within the current app session; compiled languages require their documented toolchains. Open existing local extension source projects too. Edit source, manifests, and fixtures, retain drafts and Undo history across files and project tabs, save with external-change detection, and run the existing CLI validation and runtime-fit inspection directly from Projects. Review the project's development configuration to build and test once or watch declared files, inspect live output, and stop the development session. Add an inspected project’s exact import to the model and navigate between the import and its open source projects. Copied package imports use readable, collision-safe aliases. Prepare a preserved development workspace and activate it through Package Center; source changes never refresh active bytes implicitly. Include an existing workspace's packages, review which versions will be kept or replaced, and preserve a separate combined workspace with the same policy and advisory bindings for activation review. Saving source does not install, activate, or publish a package. On macOS, native Undo/Redo now follows the focused Code editor's retained history after file and project switches, while other text controls keep native editing behavior.

• Write longer Documents with named styles, paragraph formatting, Find/Replace, heading navigation, word counts, zoom, and image sizing. Set paper, margins, headers, footers, and page numbers, then export Word or PDF or inspect the exact PDF preview. Live values are frozen at capture time; unresolved values prevent export. Word round trips retain supported styles, paragraph spacing, numbering, image sizes, unequal table widths, merged cells, repeating headers, and page setup. Desktop exports use a native Save dialog. Located conversion notes identify simplifications; the editor remains a continuous writing view.

• Review Documents with text-anchored comments, replies, resolved threads, and tracked text edits. Accept or reject individual suggestions or all changes with Undo. Supported comments and text revisions survive Word exchange; PDF publishes proposed text without changing the editable review history. Formatting and structural revisions are not tracked.

• Import Word .docx files into editable Documents. Add headings, formatted text, lists, tables, links, and supported embedded images alongside existing content, with cancellation, conversion notes, autosave, and one-step Undo. Word page layout may differ; older .doc files must be saved as .docx first.

• Attach, paste, or drop PNG/JPEG images into Chat using the selected AI provider or a compatible local model. Workbook and connector requests share source metadata, content hashes, historical windows, and live freshness deadlines. Capture the visible Grid webview on macOS, use browser window/camera previews where supported, or choose a time range in a local video to gather two to eight frames with visible clip positions. Sampling stays on the device until Send. Preview sources stop when closed or when you leave the conversation. Choose Start observation to follow a camera, shared window or selected live image input with a question and bounded call budget. Stop explicitly, inspect timestamped answers, and revisit them in Tasks. Vision model packages require publication; native audio/video inference is not included. See the image input guide.

• Choose a personal starting layer while keeping the same model and calculations.

• Customize App navigation directly in App or Code: labels, groups, drag ordering, visibility, opening view, canvas width, and an unsaved preview. Create an Overview, Brief, or Exploration using the existing surface editors and selected bindings. Follow same-model view links, navigate Back/Forward, and find accepted model values. Keep a Chat answer as editable document or notebook content with chosen live references. Inspect live values and expand contextual assistance into the same Chat conversation. Custom apps can identify a selected model value for Grid's Context panel; returning from Chat restores the app's route and selection.

• Resume device-local Chat conversations and unfinished drafts. Recover from competing saves, export a conversation, and retry interrupted requests with the current model. Recent dialogue gives follow-up questions context.

• Author JSX surfaces beside a protected draft preview; follow preview diagnostics and supported elements back to their source.

• Catch undefined model names and misspelled literal JSX bindings while editing in Code, with source underlines, clickable problems, and spelling suggestions. Draft checks discard stale results and explain when scope information is limited. Preview and apply unambiguous spelling corrections with Quick Fix, then undo them as one edit. Contextual completion includes unsaved model declarations, namespace names, and function parameters at supported compiler-recognized reads.

• Keep working files and navigation history across Code areas, with shared editor content and independent split-editor views.

• Inspect values directly from Grid model definitions, follow available provenance back to source, and load missing values explicitly. Surface bindings retain scalar and bounded range inspection. Follow calculation dependencies within the inspector and return through a trail of values with checked provenance.

• Return to model and surface source locations with Back and Forward, including definition, search, Go to Line, and preview-to-JSX jumps. History restores the correct split editor and can reopen a closed second pane at its retained line.

• Follow recorded calculations through named formulas and sheet-qualified scalar cells when the runtime supplies exact mappings, with breakpoints and source links.

• Browse model connector declarations and the runtime catalog in Connections, inspect configuration requirements, and request health checks explicitly.

• Inspect model imports and desktop workspace packages in Dependencies, follow declarations to source, and review package exports and runtime requirements.

• Edit document blocks with menus, keyboard actions, drag handles, and Undo.

• Recover document drafts after interrupted or conflicting saves, with native storage for desktop recovery and appearance/starting-layer preferences.

Improvements

• App Context distinguishes changes saved to the live model from an older model archive, while keeping unapplied source changes and save failures visible.

• Code imports link directly to their installed packages, with keyboard focus and explicit slot choices when a package is installed more than once.

• Code preview recovery preserves local form state and keeps one inert image through consecutive source errors. Small preview updates no longer clone the entire rendered surface.

• Chat stores images separately from conversation text, so full-size attachments can be retained with unfinished drafts. Repeated images share storage, and editing text does not resend already saved image bytes.

• View whole model keeps your current source position, with Back returning to the scoped editor and Forward restoring the whole-model position.

• Code source navigation avoids repeated full-model scans when mapping outline entries, cursor positions, and diagnostics in larger models.

• Dependencies preserves catalog errors when the native folder picker is cancelled, and re-selecting the same workspace retries the catalog read.

• Code syntax palettes improve faint comments, strings, line numbers, and bracket pairs across themes while preserving Data’s existing editor appearance.

• Shared appearance and desktop controls across all four layers.

• Source links connect model views and authoring without changing calculations.

Bug Fixes

• Calendar model calculations reuse dependency analysis already available in the running model, reducing repeated work when opening large calendars.

• Undo and Redo refresh named formula results, so copying a restored formula's value does not retain the number from its previous definition.

• Grid context menus stay open when a separate source editor scrolls.

• Show in Data reliably selects the value opened from App, including unqualified references after visiting another worksheet. Returning to App retains the originating view and selected-value context.

• Package actions lock immediately while starting, poll status without overlapping requests, and preserve cancellation feedback when older responses arrive.

• Package Center retires stale workspace catalogs and responses, keeps acquisition disabled during catalog failure, and provides a direct catalog retry.

• Fixed missing runtime-error source links in Code previews on macOS, including click-handler and asynchronous errors; repairing the source restores the preview.

• API operation tests clear obsolete results when inputs change and prevent pending responses from appearing under a different model or operation.

• Document link and image dialogs reject outdated edits when the document changes while they are open. Cancel returns to the latest document.

• Narrow Code editors keep Problems and investigation controls visible, including narrow split panes. Status text has stronger contrast in the shared themes.

• Returning from connector or import source links no longer adds an extra Back stop. Connections and Dependencies retain selections and filters within the current model session while refreshing catalog data and discarding old checks.

• Code reference headings show the authored filename without internal session keys, while split editors retain their shared text and Undo history.

• Rapid source edits keep their scoped file and latest text while the editor waits for the host to acknowledge the changes.

• Applying a Chat proposal before opening Data no longer reports a false calculation failure because a spreadsheet viewport is absent. App and Chat keep real update failures visible with recovery actions.

• Applied proposals retain their completed state without a contradictory stale warning. Source review identifies the proposal's original baseline.

• App assistance no longer covers Context actions in narrow windows.

• Notebook drafts can retry failed saves without bypassing protection against conflicting edits.

• Appearance menus support keyboard navigation and return focus reliably when dismissed, including in narrow windows.

• Document block dragging uses captured pointer gestures with cancellation and Undo.

• Document value pickers dismiss when you move focus away, without pulling focus back from the next control.

• Desktop recovery survives changes to the app's local address after restart.

• Fresh desktop profiles initialize their local authority file before startup.

• Help now includes the AI setup, image-input, Code, Deck, and multiple-window guides, with reachable language-reference links and clearer end-user instructions.

Apple GPU inference now preserves F16 activation rounding during generation. It also retains precision through BF16 normalization and activation, and resolves equal-score token choices consistently. Tested SmolLM2 F16 and BF16 cached scores meet their original comparison limits; repeated requests agree.

Compatibility and Migrations

Data retains its existing layout. Documents and notebooks retain their surface identities. Existing model links remain supported; the layers do not create copies of the model or change formula results.

Known Issues

• Low-precision score ties can choose a different word from a full-precision reference even when numerical comparisons pass. CUDA and packaged-model validation remain unrun for these corrections.

This is an archived, unreleased development milestone. Full validation was not completed before the release was superseded. Subsequent integrated source requires its own validation. Local recovery is not cross-device backup; Chat requires a configured provider. Code's navigation and preview tools do not claim a complete debugger or support every possible JSX source mapping.

Documentation Updated

See the interface layers guide for supported behavior and current limitations.

App refinement

App now offers clearer surface actions, editable Next steps, and contextual commands for selected native objects. Numeric and text assumptions keep unfinished input intact and show save progress or failure. Action buttons wait for accepted writes before navigating. Notebook blocks gain drag ordering, keyboard movement, Undo/Redo, and focus restoration. App Builder, Layout, and Notebook preserve pending and failed edits when navigating. The forecasting example now continues from assumptions and a report into a native Deck presentation.

App’s forecasting example now connects a readable outlook, all three assumptions, a report with live references and explicit modeling limits, and a decision-focused presentation. App keeps arrangement in View actions, brings question context into the composer, and gives new starters clearer continuation links. Deck opens for browsing and presentation; Edit slides reveals its authoring controls.

App reading and presentation polish

Documents in App combine writing controls into one strip and move occasional tools into the Document menu. Live values read naturally inside prose while remaining inspectable and editable. Deck keeps Present prominent and groups capture and export controls in Presentation options. Shared menus retain theme, keyboard, and narrow-window behavior. Data's operational layout is unchanged. The forecasting example now includes a finished illustrative planning brief, reasoning, and presentation, with currency and percentage display formats.

Author complete Grid projects in Code

Code opens Library, Template, Solution, and pretrained Model source folders with their correct manifest. Grid .grid and .gs files share Grid syntax highlighting. Move from an opened project to Registry publication review and back without selecting the folder again; saved source context and editor history are retained. Save drafts and finish active project work before preparing publication. Create Libraries or Solutions from the source workspace. New Solutions include a Grid module, model template, and smoke tests. Synchronize saved artifact hashes and run Solution tests separately, with compiled/executed counts and output in Code. Create Templates with a Grid model and catalog metadata, check their declared files, and synchronize saved hashes before publication review.

Project JSX and TSX files can now preview against a model surface with live values, source inspection, and error recovery. Saving a file and applying a model interface remain separate; an explicit Surface studio handoff protects existing drafts.

Projects, Dependencies, and Registry now have separate destinations in Code, with working tabs and Back/Forward history. Source-to-publication and dependency-to-Registry handoffs retain their context and project drafts.

Dependency reviews now carry the exact requested import into Package Center and provide a direct return to Code. After package or runtime settings are reviewed, Code marks the previous resolver report stale and offers a fresh dependency check.

On macOS, Code preserves Control+Shift+M for moving keyboard focus out of the model editor. Command+Shift+M continues to open Problems.

Grid 0.66.6 — Not released (superseded)

Summary

Grid 0.66.6 was an unreleased development milestone. Its AI setup and multiple-window improvements carried forward through 0.66.7 into the 0.66.8 release. The notes below preserve that development history.

A shared AI & extensions window makes provider setup, local-model installation, extension discovery, and registry selection easier to find and use. Multiple workbench windows share one runtime while keeping separate drafts.

What's New

• File → New window opens another workbench on the same Desktop runtime.
• Desktop and Server startup reject conflicting storage or runtime identities; intentional job workers retain shared-queue operation with distinct identities.
• Browser tabs keep independent drafts and restoration state. Main-editor saves check the source version before replacing a model changed by another session. Reloaded drafts are preserved for review without automatically replacing another session's saved source.
• AI & extensions is available from the File menu, command palette, and Agent.
• Local-model search learns family shortcuts from your selected registry, with verified model details, memory/storage guidance, measured download progress, pause/resume, model trials, and storage management.
• Installed local models can power Grid Agent and be inserted into workbooks through the same existing AI capability.
• Compatible signed model variants can use Apple GPUs through Metal. Setup shows the device selected for each model and retains CPU compatibility.
• Local model releases can include verified companion and tokenizer files in one resumable installation, with the complete download size shown up front.
• Detailed releases check architecture, quantization, engine version and conversation-memory needs before downloading, including working space and headroom.
• Restricted model downloads explain publisher access and terms. New models for supported architectures can arrive through registry updates.
• Provider connection checks discover available models without generating text.
• Signed extensions can be discovered and installed into a chosen workspace.
• Registry settings persist and are checked against an independently supplied verification code before use.

Improvements

Storage ownership checks stay outside formula evaluation. Independent documents can complete their storage checks concurrently.

The selected extension folder carries into Package Center for activation. Registry setup links fill in verified connection settings. Provider keys stay masked, with available models and custom overrides in an optional disclosure. The setup screens adapt to narrow windows and the active Grid theme.

Bug Fixes

Desktop provisions private encrypted API-key storage on first use. Keyboard navigation skips controls hidden in collapsed disclosures. Registry switching keeps independent verification history for each identity.

TensorFlow Lite models retain fractional floating-point averages. Unsupported pre-folded average operations are rejected instead of returning rounded values.

Model publishers have explicit export recipes for numeric LightGBM and CatBoost classifiers and MiniLM embeddings. Classifier exports preserve probability column order and derive labels consistently, including negative class IDs. Compatibility remains specific to the model, export settings, and device.

Apple GPU inference avoids premature rounding in normalization and BF16 attention. The tested SmolLM2 and Qwen3 models now meet their original numerical tolerances; the previously passing model and precision combinations remain valid.

Compatibility and Migrations

Existing AI functions, provider APIs, model installation receipts, and package activation remain authoritative. No additional model evaluator is introduced. Existing explicit API-key storage settings continue to take precedence. Independent runtimes now need distinct node identities and non-overlapping writable folders. API-owned key and trust files must sit outside runtime-owned trees. Standalone APIs with writable configuration require the matching storage ownership companion. Status checks connect to the running instance without starting another runtime.

Known Issues

At this milestone, the multi-window changes had not been published in an installer. They are included in Grid 0.66.8; the validation limits below describe the original 0.66.6 development work. Close older Grid versions before sharing a data directory with this version; older processes do not honor the new ownership protocol. Save work before closing a session, and close other workbench windows before installing updates. Packaged multi-window UI QA on macOS, Windows and Linux remains unrun; native Windows module compilation does not establish live Windows behavior.

Local models require the Pro AI runtime; model and extension availability depends on the chosen registry. Windows public-registry storage is implemented and cross-compiled; Windows execution and packaged installation QA remain unrun. GPU use also requires a registry release that declares a compatible GPU variant; existing CPU releases stay CPU. Apple Neural Engine execution is not implemented. Hardware selection reflects supported runtime capabilities, not a speed benchmark. Connection checks establish authentication and model discovery, not generation quality or paid model access. The default catalog currently includes Qwen and Phi. The updated engine runs the prepared Gemma profile on CPU and Apple GPU, but its complete model release still needs curator review, signing, and publication. Gemma releases with companion files require updated registry readers and the new desktop with its matching installer. Signed extensions still require permission review and activation in Package Center.

Documentation Updated

The AI and extensions guide and setup walkthrough describe the complete flow. The multiple-windows guide covers Desktop ownership and browser sessions on Server. Cloud and Dev editorial review and publication remain outstanding.

Grid 0.66.5 — 2026-09-18

Summary

Grid 0.66.5 makes scientific and analytical work easier to inspect and preserve. Numerical reports explain methods, assumptions and unsuccessful calculations; guided research starters connect editable inputs, plots and saved scenarios. The patch also strengthens source editing, input recovery and portable archives so a delayed response or failed calculation does not silently replace your work.

What's New

• Readable numerical reports. Inspect fit coefficients, residuals, rank, conditioning and stopping reasons. Explicit options add weights, parameter bounds, fixed values, local intervals or seeded bootstrap intervals, with limitations and failed refits disclosed. ODE records show the selected method, controls, work and final state. Derivative reports distinguish automatic differentiation from numerical differences.
• Calendar-aware economic series. Paste and review dated observations, inspect gaps and incomplete periods, and save a reviewed input with Undo. Lags and annual changes align by calendar period. Regression tables name estimates and inference conventions and support complete HTML export.
• Finance and operations research. Exact regular-coupon curve bootstrapping includes repricing residuals. Solver reports show labeled decisions, resource usage, slack, marginal values, flow assignments and cut certificates where supported. Saved scenarios can retain results for explicit baseline comparison.
• Scientific data review. Review matrix axes, value contracts and labels before import. Explicit centered PCA and uncentered SVD preserve their method identity. Expression comparisons select Welch t or normal references; variant views distinguish passed, filtered and unknown records. Molecular workspaces offer named property methods, adapter availability and saved provenance.
• Guided investigations. Starters and examples cover biology, chemistry, physics, materials, petroleum and aerospace engineering, applied mathematics, economics, finance and operations research. They state assumptions and provide checks, editable inputs, plots or scenario exercises appropriate to the task.

Improvements

• An experimental CAD source tab exposes the narrow imported rectangular-pad author/edit/save/reopen/measure/STEP workflow. Revision checks reject stale edits and exports. This does not promote general programmable CAD support.
• Windows startup suppresses background consoles, and desktop network discovery starts only when requested. Packaged Windows verification remains separate.
• Plot loaded ranges or named X/Y vectors after reviewing data and axis labels. New selection plots use points or straight segments. Charts show their source and explain missing data or incompatible shapes; examples are explicit previews.
• Inspect dated series, scientific artifacts and structured reports without losing complete original values. Long formulas scroll within their source area. I/O opens structured inputs in the appropriate editor and distinguishes unavailable calculations from array-placement conflicts.
• Excel formula export preserves supported named inputs and intermediate dependencies using a supporting Grid Values worksheet. Export Excel values provides an explicit static alternative.
• Model authoring is directly available through Edit model. Expose named outputs with descriptions; ordinary workbench setup suggestions are optional.
• Repeated result reads and input updates avoid redundant decoding, copying and overlapping refreshes. Uniform-height grids avoid rebuilding full row layouts. These targeted changes do not establish a general performance ranking.

Bug Fixes

• Experiment outputs requested by cell address now bind to the intended model cell, consistently with experiment inputs and saved replay.
• Model opening, starter creation, library changes and result refreshes discard superseded replies. Older model values and errors no longer replace a newer selection or source revision.
• Saving distinguishes accepted source, available calculation and confirmed archive persistence. Failed refreshes retain accepted inputs, editor drafts and Undo, with explicit retry guidance. Unavailable results are withheld instead of being presented as current values.
• Dormant saved inputs survive source changes and archive restoration; Reset can discard them. Invalid dated series are rejected before mutating models, including series nested in typed collections and incoming provider batches. Rejected deliveries remain rejected on retry and after restart.
• Provider deliveries respect source ordering and later manual edits. Selected local-input batches recover through their durable state without repeatedly applying the same update. Background decoder failures and timeouts can recover using bounded retained response data.
• Multiline edits preserve exact whitespace through recompilation and Undo. A1-style field access retains dependencies; out-of-range negative indices no longer accidentally select a whole row or column. Unrepresentable addresses are diagnosed before they can collide with another cell.
• Root solvers, scalar minimizers and exhausted large curve fits report nonconvergence rather than returning an unfinished estimate as success. Whole-weight knapsack rejects fractional or malformed inputs. Portfolio functions reject incompatible dimensions and missing numeric positions.
• Regression rejects zero confidence, improves extreme interval precision and explains established complete separation. EXPM1 preserves small exponential differences. PDE options accept the documented ninth-argument record.
• Scientific archives recognize their writer's Frame and numeric-matrix encodings while retaining identity checks. Molecular adapter digest checks preserve decimal values and reject duplicate JSON keys. Sequence operations retain upstream alphabet errors.
• Compound unit parsing accepts forms such as m^3/s; petroleum conversions include psi, bbl, darcy, mD and cP. Physical-scale warnings explain known mismatches; unit_scales strict opts into enforcement.
• Chart failures release incomplete instances and expose a retry action.

Compatibility and Migrations

• New functions, reports and reviewed scientific operations require a matching updated runtime. Existing saved artifacts are not rewritten automatically.
• Existing curve-fit scalar/coefficient contracts remain available. Report defaults use equal weights and no constraints; explicit options select additional inference. Calls without uncertainty options retain schema v1. Local intervals are approximate individual parameter intervals, not simultaneous or prediction intervals. Constrained fits decline unsupported local inference.
• Existing BIO_OMICS_EMBED calls without a method keep uncentered SVD behavior. Older artifacts labeled sparse_pca are not retroactively centered. Use BIO_OMICS_EMBED_V2 when explicit method semantics must be enforced by the runtime. Corrected normal tails do not replace the distinct Welch t method.
• The original approximate curve-bootstrap function retains its results; exact regular-coupon bootstrapping is an explicit selection. Molecular provenance is additive; exact-object consumers should allow it.
• Explicit source addresses must fit columns A–XFC and rows 1–67,108,863. Previously unrepresentable addresses now fail explicitly. Use an underscore in descriptive names that resemble unsupported addresses.
• Root-solver iteration exhaustion now returns CALC. Whole-weight knapsack requires integral weights; use the mixed-integer formulation for fractional packing. Leading-minus/power precedence is unchanged; the grouping warning offers explicit alternatives without rewriting source.
• New petroleum unit names may conflict with custom declarations. Remove an equivalent declaration or rename a different convention. These conversions do not supply gauge offsets, reservoir factors or gas reference conditions.
• Formula exchange targets supported numeric calculations within a 100,000-cell budget, not complete Grid-to-Excel equivalence. Unsupported behavior receives diagnostics; use values export or a Grid document as appropriate. EXPM1 is not supported in formula exchange and has no implicit array overload.
• PDE eight-argument defaults and numeric sample counts remain supported. In the legacy ten-argument form, the final record replaces all options; its samples defaults to 101 and argument nine is not evaluated.
• New provider ordering and pending-batch journal records require an updated host for recovery. Older hosts refuse those records rather than silently ignoring the new state.

Known Issues

Portable molecular descriptors remain uncalibrated proxies, including their derived Lipinski flags. Use an explicitly supported adapter for a named calibrated method. Weak or nonlinear study designs can still produce misleading fit intervals even when a calculation converges.

The native chart-rendering discrepancy reported in the materials study remains under investigation. Source checks do not establish that a packaged application has resolved it. The agent-operated studies and synthetic examples do not establish comparative superiority or substitute for human research validation.

The experimental CAD editor does not preserve drafts across model switches or workspace closure, and does not refresh pinned imports. Its checkpoint is not a portable Grid-document archive. Copy unsaved work before leaving the editor. The selected workflow's earlier live investigation also retained background request errors; it does not establish an error-free packaged CAD experience.

Documentation Updated

• Function reference and error guidance
• Excel export and quickstart
• Molecular biology and computational chemistry
• Reviewed canonical examples and research starters with assumptions and checks.

Bundled documentation is prepared with this source. Website publication remains a separate operation.

Grid 0.66.4 — 2026-09-11

Summary

Grid 0.66.4 makes surface configuration and embedded code easier to read, edit, and format with explicit language blocks.

What's New

• New surface configurations use <toml>…</toml> blocks. Use <yaml> or <json> to author the same structured configuration in another format.
• New surface document seeds use <json> blocks. Component source continues to use <jsx> blocks, where braces retain their JavaScript meaning.

Improvements

• Documentation sites and the in-app reference share a changelog and capability highlights. Bundled docs describe included changes; websites distinguish upcoming changes from released features. Significant capabilities stay discoverable beyond their release date.
• Surfaces apply their existing configuration schema checks to resolved structured values as well as legacy TOML strings.
• Configuration saves, surface renames, duplication, and embed edits retain language blocks. YAML setting edits preserve comments on unchanged content.
• New generated data blocks use a two-space margin when the parsed value stays unchanged. Public examples use section spacing and concise intent comments.
• The formatter preserves authored data blocks and prefers them for multiline structured literals, retaining embedded comments and indentation.

Bug Fixes

• Keep quoted markup containing Grid expressions in its quoted form during formatting, preserving its evaluated meaning.
• Treat embedded blocks as single assignments when editing source, so assignment-like text inside code does not become an edit target.
• Preserve nested TOML quotes and use safe quoted forms when a payload contains its block's closing delimiter.

Compatibility and Migrations

Existing models with plain TOML configuration strings continue to work. Their next configuration save uses typed TOML; no bulk source migration is required. Short typed quotes remain supported.

The language already supported these tags. This update changes surface authoring, configuration handling, and formatting. It does not change how ordinary formulas calculate their results.

Known Issues

Windows first-launch reports include an unexpected terminal window, network permission prompts, and failure to reach the application. Corrections to background-process launching and automatic LAN discovery are prepared in source; they are not yet verified or delivered in a replacement Windows installer. A valid signature does not guarantee that SmartScreen recognizes a download.

A matching closing tag inside a payload ends the block, including inside an embedded string or comment. Use a safe quoted form for that content. Quoted markup can interpolate Grid expressions, so preserve the intended distinction between verbatim source and interpolated markup.

Documentation Updated

The surface guide, language reference, assignment reference, and AI authoring guide now teach language blocks and explain compatibility and interpolation. The style guide, surface specs, and canonical surface examples also use the new convention.