GizStack
View .mdOpen in ChatGPTOpen in Claude

Changelog

The changes that affect people who use GizStack, newest first. Toolchain releases and their files are on the install page and in the release catalog.

Each entry is the Changelog: trailer of the commit that made the change, listed when the site is deployed. The entries up to 2026-10-20 were written here before the trailers.

2026-10-27

  • Editing a .ghtml page in live mode is checked incrementally and recompiles only the units it changes.
  • Drive storage note records the P4 site gate.
  • GizFS site drill and local-disk encryption guidance.
  • none
  • Dir.watch on a GizFS mount hears other machines' changes (WATCH_ELSEWHERE).
  • gizstack builds again on gizlang main (E_EFFECT in Table.analyzeAside).
  • giz deploy deploys a whole project folder (any giz init template) to GizStack.
  • GizFS mounts answer stat without a volume call and list
  • giz live pages update the moment an edit publishes, with no polling.
  • none
  • GizFS mounts list and close without waiting for the queue,
  • none
  • GizFS mounts support mv -n, chunk-sharing cp and df; a storage
    node can keep its bytes, encrypted, in an S3-compatible bucket.
  • Programs that import GizWeb or GizDesk components check and build with an installed toolchain again.
  • GizDesk's secure mode no longer needs GIZDESK_SESSION_SECRET; sessions sign with a key derived from the Desk's key (sign in again once).
  • gizlang:worker has call, the caller side of the worker protocol; gizai:workerclient is removed.
  • Desk sets its speech and talking-head workers in Connections, Services; the Claude subscription sign-in is removed (use an Anthropic API key).
  • none
  • none
  • none
  • Tree.openObjects takes the host's tenant.
  • The docs gate requires the site's frontmatter description.
  • none
  • A changed pinned source reports the file and giz get ..
  • Gizlang files carry SPDX headers (REUSE 3.3) and Desk uses gizdesk-* wire names
  • GizStack uses GizDesk's gizdesk-* Image, socket and header names
  • GizStack mail and office editing use the shared gizlang:mail and Desk Drive owners
  • Desk Drive gains S3, office engines, mail invitations and unlimited streamed uploads; gizlang:mail added
  • Gizlang is now Apache-2.0; GizDesk is AGPL-3.0-only.
  • none (internal cleanup of GizDesk connections)
  • fixed giz live of Desk with Drive and the Cell agent
  • GizDesk has its own Drive at /drive (files, sharing, search, activity) without giz.ai.
  • changed
  • fixed
  • Desk owns the Drive action input types (gizdesk:drive/actions).
  • Desk owns Drive (S3, share links, homes, replication, the Drive view) and the Cell agent, usable without giz.ai.
  • Data Studio queries returning fewer rows than the limit work.
  • Library units with large records compile several times faster.
  • Deeply nested markup no longer fails with E_LEX.
  • Type-checking large packages is up to 5x faster.
  • tools/perf/profile.giz profiles a whole command, compiler processes included, with baseline diffs and folded stacks.
  • Agent publication settings live on the shared Desk Assistant.
  • Canonical Desk Assistant profiles retain publication configuration for shared host composition.

2026-10-26

  • SoulX workers report the model actually loaded on the shared GPU.
  • Shared agent capability modules are declared public in the structure ownership map.
  • Relative GHTML imports work when consuming compiled toolchain libraries.
  • Agent connection scopes share exact operation filtering across hosts.
  • Hosts can configure the public Desk agent with their own models, scoped tools and profile settings.
  • Desk record creation preserves caller authorship and agent resource scope.
  • Formatting non-ASCII text before a slash no longer crashes.
  • Ordinary package snapshots preserve module-only libraries, native grants and one identity per source.
  • JSON action inputs can validate scalar kinds before decoding.
  • Keep Desk agent records independent of cloud embed settings while preserving scoped execution and provider call metadata.
  • Public Desk profiles retain publication settings and scoped connection grants for shared hosts.
  • Recover interrupted Desk runs with renewable leases and preserve committed tool results across restarts.
  • Hosts can import the shared GizDesk workspace and capabilities.
  • Steering an active Desk conversation returns its existing persisted run.
  • Desk documentation distinguishes the public package from the ongoing cloud consumer migration.
  • Web handler regression fixtures follow the shared action operation contract.
  • GizWeb documents reusable chat presentation exports and Desk browser failures expose startup diagnostics.
  • Cloud chat presentation consumes reusable GizWeb types independently of the Desk runtime.
  • GizDesk owns its agent product model and durable execution while GizWeb exposes reusable chat presentation components.
  • The public site explains the complete stack and exposes one consistent developer documentation map.
  • SoulX workers share model selection and consistently report native loading and input failures.
  • Developer documentation introduces the whole stack and combines compute with generative AI in one guide.
  • Ordinary package snapshots preserve module-only libraries, native grants and one identity per source.
  • Typed actions can return structured results such as source lists.
  • Typed actions can return structured results such as source lists.
  • SoulX inference separates request state from shared weights and declares Lite/Pro model geometry.
  • Ordinary packages can import toolchain libraries and GHTML dependencies.
  • Ordinary packages can import toolchain libraries and GHTML dependencies.
  • Hosts can reuse MCP discovery and invocation without a second protocol client.
  • Hosts can reuse MCP discovery and invocation without a second protocol client.
  • GizDesk has a public import namespace and shared workspace imports.
  • GizDesk has a public import namespace and shared workspace imports.
  • Actions can declare independent execution and approval metadata.
  • Actions can declare independent execution and approval metadata.
  • GizStack release sources include the public GizDesk package.
  • Reserve the checkout and plan route names for the console.
  • Prepare a signed GizStack release before production preflight.
  • Node directory listing follows libuv scandir ordering.
  • Dynamic import accepts URL objects and other string-convertible specifiers.
  • CommonJS export getters now run when modules are required or imported.
  • Work list exits with an error when task records cannot be read completely.
  • Health checks changes in both repositories and reports unavailable work inventories as errors.
  • none
  • Documentation menus and capability links follow the current guide locations.
  • GizDesk reports invalid arguments, preserves RTL layout and ships runnable data and ML guides.
  • GizDesk keeps existing conversation projects when upgrading from Chat.
  • Character mode can animate uploaded portraits with local speech and FlashHead video workers.
  • Unify JSONB mutation index validation.
  • Centralize LLM KV cache layout and quantization format ownership.
  • Add split agent workbench and enforce dynamic tool policies; cover chat UI and agent runtime.
  • Decouple VM native call stubs and LLM vision conversion.
  • Discover 57 native ML task combinations, compare models and deploy portable preprocessing pipelines from Gizlang code.
  • Preserve older chat folder assignments as projects and pass their shared context to delegated agents.
  • Centralize tensor storage and vector math ownership.
  • Add native text-layer PDF search, durable project contexts, and opt-in private Chat Studio login with verified file protection.
  • Fix artifact creation and improve knowledge search relevance and mobile editor navigation.
  • Add comparison chats, searchable models, pinned and archived conversations, project labels, knowledge uploads and editable artifacts.
  • Unified ML guide, safer model files, reproducible splits and bounded multi-source queries.
  • Add checked standalone ML APIs and idempotent external CDC batches for GizWeb live views.
  • Refresh the chat example with responsive studio navigation, conversation renaming, improved composer and accessible agent controls.
  • Clarify TLS support and secure client configuration in the GizDB server guide.

2026-10-25

  • Reduce internal dependency cycles and remove unused generated data.
  • GizDB usage and server operations now live together under Guides, with expanded setup and troubleshooting coverage.
  • Reduce repeated exact-decimal comparisons in stored sorts.
  • Throw ReferenceError for unresolved global identifier assignments in strict JavaScript.
  • Preserve getter side effects when copying array-like call arguments.
  • Optimize Python list slice rotation, in-place list addition identity in JIT, set probing, and len() intrinsics.
  • Fix JavaScript subclass constructor metadata inheritance, strict mode directive handling, and async generator property extensibility.
  • GizDB delivers row before-images for continuous journal updates and live watch notifications.
  • Avoid repeated row and column conversion when collecting stored query results.
  • Support sparse arrays, indexed descriptors, independent array length writability, and primitive wrapper objects while preserving guarded dense fast paths.
  • Reduce time-range lookup work and disk-window scheduling overhead.
  • Preserve composite-key prefix lookup performance after REINDEX.
  • Preserve getters, inherited indices, mutations, and live iteration in JavaScript and TypeScript array methods.
  • Bound LAG execution and reduce wide analytical window work.
  • Fix PostgreSQL typed loads and composite primary-key metadata.
  • Fix migrated key lookups and bound database maintenance memory.
  • Improve JavaScript callable properties and Unicode parsing, Python attribute protocols, and array-like search semantics.
  • Array-like callbacks observe the original receiver and preserve large JavaScript indices.
  • Parse SQL keywords without allocating lowercase strings and reuse tokens when no qualified operator needs normalization.
  • Repeated calls of closures sharing a function body can retain JIT specialization.
  • VM profiles can name JIT functions, and VM benchmarks can compare an interleaved baseline.
  • Preserve initial callback lengths and inherited array indices during JavaScript iteration.
  • Read validated form values and uploads with one multipart parse, and reject malformed form bytes before processing submissions.
  • Prepare Python native modules automatically for Gizlang programs launched with giz run.
  • Preserve Python list identity and collect fresh JIT feedback after guard failures.
  • Fix closure capture error in OmniVoice realtimeStream.
  • Add GIZLANG_LLM_PROBE to settings reference and preserve toolchain text assets.
  • Dynamic speculative decoding defaults (up to 670 tokens/s) with configurable --drafts option
  • Accelerate FP8 GEMV decoding via shared memory lookup table, achieving 3.75x decode speedup
  • Accelerate Python slice rotation, tuple conversions, and eager set comprehensions
  • Support typed constant annotations in Python script files and update guide examples.
  • Clarify npm packages, pip packages, and .so shared library usage in C/C++ and JavaScript/Python guides.
  • Import JavaScript, TypeScript, and Python files directly into Gizlang as first-class modules.
  • Accelerate Python class method lookup, polymorphic IC, and reversed ranges

2026-10-24

  • giz live on Windows runs calls of the program's functions; each one faulted.
  • ai worker ltx2-5-distilled --text FILE serves LTX-2.5's text encoder, for prompts of any length.
  • GizDB GROUP BY of many distinct keys and length() of long text are faster.
  • LTX-2.5 in/outpainting blends its frames on the GPU, about 15 s faster for 121 frames.
  • LTX-2.5 takes depth control videos (DVG).
  • giz live on Windows links programs that use the system API (process, CPU and memory facts).
  • A source file that starts with a UTF-8 byte order mark compiles; giz fmt removes the mark.
  • GizDB benchmark results updated (ClickBench 0.56 of DuckDB; pgbench -i 0.7 s).
  • A hosted app on SQLite has accounts, and its people move with it to GizDB.
  • Accounts (gizweb Auth in a schema) work on a SQLite store, and move with it to GizDB.
  • GizDB's current_schema() follows search_path.
  • GizDB joins a fact table to a dense dimension faster.
  • In a CI run, the tests that need a capability that its host lacks run on a host that has it.
  • Krea 2 Turbo loads again (it failed at start with R004).
  • WebP pictures in lossless (VP8L) form now decode.
  • A GROUP BY of many groups takes less time.
  • A join from a fact table to a dimension with dense integer ids takes less time.
  • A worker ends after a kernel fault leaves its GPU context lost, so the next job runs on a restarted one; an H3 request without room fails with WORKER_NO_MEMORY.
  • pgbench -i loads its accounts in one chunked group, also after its INSERTs of branches and tellers.
  • An LTX-2.5 worker encodes a 1080p input video in the memory it frees, or fails that job; it no longer exits.
  • An isolated process (SpawnOptions.isolated) can use its own loopback, so a hosted app can serve its own GizDB folder.
  • Windows: gizdb serve starts; unix-domain sockets are named pipes.
  • Windows: giz live, kernel units in gizdb and the JS/Python VM; libraries built at -O2.
  • A join to a small range of dimension keys takes less time.
  • A LIKE pattern with a fixed prefix or suffix takes less time on the strings that miss it.
  • The guides pass a helper the narrowest value it needs, such as a Dir, instead of the whole System.
  • The guides and examples use throws and try/catch instead of Result.ok.
  • A transaction that COPYs into several tables (pgbench -i) loads them in chunks at COMMIT, not row by row.
  • Joins of a fact table to its dimension and integer GROUP BY folds take less time.
  • giz fmt --tree rewrites the files of a package's subfolders, and one file that fails no longer stops the rest.
  • On macOS, a child process now ends when the program that started it ends, as on Linux and Windows.
  • Fixed Cell.version and Cell.wait for a cell made after another cell was closed.
  • A new guide, C and C++ (docs/guides/c-cpp.md), shows how to import C and C++ files and call C libraries.
  • A C call whose argument does not fit its C type now fails with R003 in every caller, not only in the function that makes it.
  • GizDB benchmark results updated: ClickBench 10M at 0.61 of DuckDB 1.5.6's time, TPC-H SF10 at 0.76.
  • The VM compiles recursive functions such as fib about 20% faster.
  • The benchmarks page shows LLM serving against vLLM and MAX.
  • Tokenizing a long prompt for Gemma models is many times faster.
  • Batched Gemma 4 decode is about 10% faster.
  • Gemma 4 answers no longer start with the word "thought".
  • npm i -g @gizai/cli works on Windows: the first giz command installs the Windows toolchain.
  • Gizlang runs Gemma 4 dense models (such as Gemma 4 12B).
  • giz test and giz check run tests on Windows.
  • none
  • gizai:agent takes settings (reasoning effort, max tokens, temperature, top_p, seed, stop); AI_EFFORT sets a default.
  • Batched LLM decode is about 2% faster: split GEMM sums are added by the next kernel.
  • Fixed a stack overflow (R009) in long loops that drop records of more than six words, in -O2 builds.
  • none
  • Time-range filters such as ts > now() - interval '1 day' now skip the blocks of a stored table that cannot match.
  • gizlang:math exports absI64.
  • LLM decode with drafts is up to 1.4x faster on GPUs with matrix cores (draft steps attend by tiles).
  • gizlang:url exports writePercent(out, byte), one byte as "%XX".
  • Prepared statements whose conditions read parameters now scan as fast as the same statement with literals.
  • Fixed count(*) beside count(DISTINCT ...) without GROUP BY, which could answer several rows or fail with a state error.
  • LLM serving gives the first token of many chats at once up to 2.4x sooner on a GPU (chats stay in the KV pool).
  • LLM prompts longer than 1024 tokens read faster on a GPU (GEMM tiles tuned per 128 rows).
  • INSERT ... SELECT and COPY into a table with a generated column load in chunks within the memory budget.
  • A query by a parameter on the leading key column of a large table scans instead of failing with "not enough memory".
  • Comparing a text column with a quoted literal uses zone maps and key reads again.
  • GPU prompt reading is about 2% faster: attention copies key pages faster.
  • ALTER TABLE ADD COLUMN fills, window rankings and large UPDATEs of tables with generated columns run within the statement's memory budget.
  • gizlang:url exports percentDecode(bytes), the URL Standard's percent-decode.
  • On Windows, giz run, test and build link programs: link commands with backslash paths parse, and notices use the Windows components.
  • LLM attention on NVIDIA GPUs is faster: exp2 softmax weights, unmasked flash turns, longest tiles first.
  • LLM prompt steps on NVIDIA GPUs are some 7% faster (GPU embeddings, 16-bit GEMM outputs).
  • v = [...v, x] runs in linear time for a Vec of any element type.
  • s.concat(a, b) joins strings and bytes, and v.concat(a, b) takes several Vecs, as in TypeScript.
  • v = [...v, x], v = v.concat([x]) and v[i] = push(v[i], x) append in place, in linear time.
  • Iterating a Python array.array is several times faster.
  • A Python traceback includes the frame that catches the exception, and a bare raise keeps the original line.
  • Python class calls with a simple __init__ run inline in compiled code.
  • A loop that builds text with a template (t = \${t}x``) runs in linear time.
  • A cold build prints each toolchain library unit's build time.
  • LLM prompts are read up to 20 % faster on NVIDIA GPUs.
  • GPU tunings kept on disk are measured again after an upgrade, so old choices no longer slow new kernels.
  • giz fmt --tree keeps the Result of a function whose Result a local passes on as an argument.
  • A bulk load (COPY, INSERT ... SELECT) that does not fit the server's memory fails with 53200 instead of stopping the server.
  • Comparing an integer column with a quoted literal that is not an integer fails with 22P02, as in PostgreSQL.
  • COPY ... TO STDOUT works over the extended protocol (drivers that always Parse/Bind/Execute).
  • Python operators on class instances (-, *, % and the others) call their dunder methods directly from compiled code.
  • Python isinstance and % formatting run faster.
  • On Windows, giz run, check, test and build accept the paths the system gives (C:/...).
  • A bound function keeps the name and length its target had at bind.
  • Reading a function's name or length is cached.
  • Spread calls and Python's abs() run in compiled code.
  • JavaScript super(...) and new of derived classes run in compiled code.
  • LLM prompts start faster: the engine reads a step's token embeddings with one file open.
  • The LLM engine no longer loads Gemma 2 models.
  • ORDER BY on a NUMERIC key that holds NaN with LIMIT answers NaN instead of an execution-state error.
  • A cast to a type that does not exist fails with 42704 (type "x" does not exist), as in PostgreSQL.
  • Agents on the Responses API reuse the provider's prompt cache across rounds and report cached tokens.
  • giz check takes several files.
  • In editors, Go to Definition works on declarations, import * as names, type parameters and implements names.
  • An LLM server warms every prompt size it tunes for, so later chat turns start in about 40 ms.
  • s.withoutPrefix(p) and s.withoutSuffix(p) return a text without a leading or trailing part when it is there.
  • LLM prompts read about 14% faster on NVIDIA GPUs, and models without an MTP layer draft tokens by prompt lookup with the same output.
  • Nemotron ASR transcribes about 7x faster on a computer with an NVIDIA GPU.
  • gizlang:locale exports SKELETON_NAMES and CATEGORY_NAMES.
  • Text.lowerHex tells whether a text is lowercase hexadecimal, and Text.charWidth gives the length of a UTF-8 sequence from its first byte.
  • Data.watch follows rows and follows again by itself when the store retires the follow.
  • JSON.stringify copies each string once less.

2026-10-23

  • Store.recount on a PostgreSQL source sums the rows at the source, in key slices.
  • A release's gizdb compiles new kernel shapes with the giz beside it when GIZLANG_CLI is not set.
  • A COPY that does not fit the server's memory fails with 53200 instead of stopping the server.
  • A memory-limit fault (R011) prints a census of the process's memory after its stack.
  • A task that has held its thread for 1 s while other tasks wait is named on stderr while it still runs.
  • gizai:agent takes a check, a last review it is told once before it finishes a run.
  • HTTP pools no longer fail a request on a connection the server closed while it was idle.
  • A task that holds its thread for 100 ms or more while other tasks wait is now named on stderr; runtime.md lists what suspends a task.
  • bytes.lossy() reads any bytes as text, and Output.ran no longer faults on output that is not UTF-8.
  • Appending Native.read(at, n) to bytes copies once, with no temporary buffer.
  • The throws rewrite refuses a tree where a program does not check, and changes nothing.
  • Code with large records compiles up to 6 times faster.
  • A throws function can return a value whose type comes from the return type, such as Option.none().
  • A stalled model ends the turn as "Interrupted" and Stop works at once.
  • AI_API=responses runs agents on OpenAI's Responses API, keeping the model's reasoning across tool calls.
  • Documentation examples match their files again.
  • Stopping an answer takes effect at once; a model that goes silent ends the answer as interrupted.
  • Result.unwrapErr() returns the error of a failed Result; Test.noise and Bench.numberAfter join the test and bench modules.
  • A live host's resource limits hold the program it runs; its builds run outside them.
  • New members get giz.ai's first-day offer on Go and Pro for 24 hours.
  • RegExp.prototype.exec and JSON.parse of objects of one form are faster.
  • Polymorphic property reads stay in compiled code after they meet a new object shape.
  • Members change, cancel or keep their plan and update their card from Billing.
  • The model hub and the JavaScript runtime use the same cache folder as the CLI ($XDG_CACHE_HOME/gizlang when it is set, LOCALAPPDATA on Windows).
  • The VM's host and Node functions declare their failures with throws.
  • Assets.minifyScript lays out the code inside a template's ${ }, and leaves a script it cannot read as it is.
  • A new app's name is cleaned the same way as a chat's title.
  • bench/agent/tbench.giz compares agent harnesses on Terminal-Bench.
  • The build cache is pruned as soon as its disk runs short, not only once an hour.
  • Each gizdb cluster database logs in with its own password (a host setting), and no statement can set gizdb.archive, gizdb.backups or gizdb.password; ALTER SYSTEM is refused.
  • A /* inside a doc comment no longer drops the doc.
  • GizStack sells credits, plans and team seats from the usage page.
  • gizdb cluster refuses ALTER DATABASE … SET gizdb.archive and gizdb.backups from a client (42501); the host sets these server paths.
  • giz check of an SDK module checks it in the SDK.
  • giz live shows what a long build is doing, such as a library unit that it builds after a compiler change.
  • Store.open takes ?pool=N on a postgres:// location to keep fewer connections.
  • BACKUP TO 'name' writes only below the server's --backups DIR folder; a server without it refuses BACKUP.
  • On Linux a process that sys.spawn starts ends when the program that started it ends, also when that one is killed.
  • the console's chat shows how full the agent's context is.
  • Agent.title(sys, model, first, instructions?) and TITLED.
  • Store.Plan takes an optional where filter, so copy, follow and recount read and prove only the source rows it admits.
  • Pages.app runs on a gizdb or PostgreSQL server that DATABASE_URL names.
  • GizWeb has Check (a checkbox cell) and Chip (a short tag), and the todo example uses only GizWeb components.
  • { ...x } copies a record whose type has private fields, from any folder.
  • A .giz file in a folder of pages is an endpoint that exports handle(props); Application.route is removed.
  • GizDB's GROUP BY and joins past their memory share read their input once and write each row once to temporary files, instead of reading the input again for every pass.
  • ALTER TABLE ... RENAME TO inside a transaction block renames the table without copying its rows; pg_stat_gizdb.table_rewrites counts tables an ALTER TABLE wrote again.
  • Assets.minifyScript and Assets.imports read scripts with the VM's JavaScript scanner (gizlang:jslex).
  • Open live pages no longer render again and again when the app reads many tables.
  • A page that reads many tables in one action no longer fails with "native cursor capacity exceeded".
  • giz fmt on an unchanged file takes milliseconds, and fmt no longer waits for build slots.
  • A sign-in link of an app whose people are in schema auth works again.
  • giz doc --package FILE documents only the package's own modules, not the libraries it imports.
  • giz FILE no longer waits behind another large run's build, and says when all its slots are busy.
  • LSP hover shows a signature in the same spelling as giz doc.
  • Store.copy, Store.move and gizdb migrate prove a copy with the same order-free checksum.
  • The chat no longer uses a full core while idle; Send and Stop respond at once.
  • nemotron-asr transcribes speech on the CPU; the chat orb hears speech without a model API.
  • giz ai index is now giz ai registry; a model folder's plugin.giz is family.giz.
  • gizai:tensor is a folder: import gizai:tensor/core for the Tensor, and random, lazy, gpu, mma or reduce for the rest.
  • gizai:llm, gizai:netops, gizai:video, gizai:ml, gizai:tile and gizai:onnx are folders; import the module that owns a name, such as gizai:llm/model or gizai:tile/ir.
  • A model family is a plugin folder under ai/models; giz ai index lists it, and giz ai worker serves any family's worker.
  • gizai:ltx is now gizai:models/ltx/{model,generate,text,upsampler,audio}; its VAEs are gizai:parts/videovae.
  • gizai modules moved: gizai:parts/{dit,flow,clip,wav2vec}, gizai:models/NAME/..., gizai:llm/{npu,grammar}, gizai:tasks/{image,video}, gizai:agent/{mcp,a2a}, gizai:ml/{trees,svm,cluster}.
  • *.module.css sheets no longer rename their classes and Graph.cls is removed: scope a component's style in its .ghtml file.
  • A table read inside a template string's ${...} in a .ghtml page is live and its .length is the table's total.
  • giz fmt and editor formatting no longer start the compiler to check each layout.
  • Pages.app takes handlers of its own (route) and many people signed in by Auth (signIn).
  • giz repl runs an entry with brackets inside nested templates at once.
  • Editor folding is right around regex literals and nested templates.
  • none (test).
  • giz doc NAME answers in seconds when the SDK has not changed since the last call.
  • A gizvm program reports a missing GIZPYTHON instead of loading a stale CPython runtime.
  • A local Vec<T> can be passed where a function takes View<T> or MutableView<T>.
  • The giz.ai Drive card folds under the Drive heading, so the team's files show first.
  • A hosted app's and a Database's sign-in use gizweb Auth in schema auth; a team's own users table is left alone.
  • A page action's writes are one transaction; Data.inSchema keeps records in a schema; Auth.personOf reads a token; Auth ids are UUIDs.
  • A _name field is private to its folder, not its file, so a module can be split into a folder.
  • The VS Code Test Explorer lists every test that giz test runs, also tests that are not exported.
  • GizDB transactions keep their snapshot after a refused write inside a savepoint; ROLLBACK TO continues them.
  • giz test ends a suite when its program exits, even if a process it started still holds its output.
  • Go to Definition opens Math.max and the other Math functions.
  • giz check and the editor are much faster on large programs.
  • The VM appends to arrays and lists in compiled code.
  • The language server checks a burst of edits once and honors $/cancelRequest, so hovers and completions answer sooner while you type.
  • The VM inlines callbacks of composed functions and native loops deeper.
  • Editors get hover, Go to Definition and semantic tokens from the running compiler, not a new check of the whole project.
  • GizDB's change feeds, server startup and cluster process waits wake at the event instead of polling every 1 to 20 ms.
  • Go to Definition reaches fields, union cases such as Result.ok, locals, parameters and SDK names.
  • giz live prints a line every 5 s while it builds, and says why the program ended when it ends unasked.
  • giz live replaces the code of lambdas too: a running Http.serve handler answers with the edited code, with no restart.
  • When the VM cannot reserve its memory, the error names the range, the address and errno.
  • Auth.signIn(sys, db, email, password) takes the system; it rehashes imported bcrypt passwords at first use.
  • The VM compiles property reads in nested loops of top-level code with their own feedback.
  • Intl segment() and formatToParts results no longer hold freed objects after a collection.
  • Task.Cell.wait(seen, ms) waits for the next store to a cell from any thread, and Cell.version() gives its count of stores.
  • The VM runs string building, Map, RegExp exec and loop-heavy top-level code faster.
  • gizweb OAuth (was Auth.OAuth): identities carry the provider access token and its expiry; OAuth.started reads a pending flow.
  • Drive search no longer fails with "Internal error" after the first search of a session.
  • Go to Definition reaches constants of other modules and standard-library functions; .giz files show the Giz mark in VS Code.
  • giz test AREA no longer faults when tools/cli/npm has its node_modules installed.
  • The source of @gizai/cli is tools/cli/npm in the Gizlang repository, under the MIT license.
  • giz vscode finds VS Code where it was installed, and says how to install it when it is missing.
  • giz codec refuses a file that does not check again; giz outline --json says whether the program checked.
  • Python continue and break in a loop's else clause now act on the enclosing loop.
  • The console serves giz.ai's community, old addresses and media.
  • The disk executor runs every aggregate and join by hash in passes; a statement whose hash state passes its share at 64 passes fails with an out-of-memory error instead of sorting.
  • Html.sanitized(html) makes untrusted HTML safe to show.
  • The VM builds long strings by concatenation in linear time (s += t no longer copies s).
  • gizai:ai is split: images are gizai:imagegen, the video model gizai:videogen, an app's models gizai:studio and the OpenAI server gizai:serve; the shared diffusion block is gizai:dit and the flow schedules gizai:flow.
  • A test folder that needs cuda runs only on a host with an NVIDIA GPU, and its tests fail rather than pass when no GPU is found.
  • giz fmt --tree ROOT... rewrites exported Result<T, E> functions as T throws E when every program under the roots keeps its meaning; --count lists them.
  • INTERSECT ALL and EXCEPT ALL past the memory budget run by hash in passes.
  • GizDB runs FULL JOIN, UNION, INTERSECT and EXCEPT by hash in passes on large inputs, and a NUMERIC group key keeps its own scale.
  • Python's re on the VM is faster: one native scan for findall, finditer, sub and split.
  • The chat composer keeps its message box full width when the form carries hidden fields.
  • The toolchain builds for Windows x64 (x86_64-pc-windows-gnu).
  • GizDB no longer faults (R014) on a query after a statement that took the tables' memory to finish.
  • giz fmt writes a module's own Result<T, E> function as T throws E where the meaning stays the same.
  • Hosted-app OAuth sign-in sends PKCE (S256) and an OpenID nonce.
  • GizStack serves a GizDB folder from a gizdb process: set STACK_GIZDB, or keep gizdb beside the toolchain.
  • gizlang:hub keeps only the hub download; the OpenAI chat client is gizlang:openai and sign-in is gizlang:signin; chat messages are one Message type with a content field.
  • array.array item access in Python, JSON.parse, JSON.stringify, Array.prototype.join and RegExp replace run faster.
  • Python loops over reversed(range(...)), truth tests and attribute reads of objects of several classes run faster in compiled code.
  • gizdb cluster --tls-cert/--tls-key ends TLS itself; Postgres.accepted, Http.Limiter.spendAll and Http.Budget are new.
  • Http.encodeForm, Http.encodeKeeping, Http.retryAfter and keyed Http.Limiter.spend/used are new; giz npm downloads honor a Retry-After date.
  • The AI gateway serves media models on OpenRouter, Vercel AI Gateway, Vidgo, API Mart, Picsart and DeepInfra, and adds POST /v1/audio/speech.
  • gizdb:store is a client of a gizdb process. Open a GizDB folder in your own process with Embedded.open from gizdb:embedded.
  • A program can import C and C++ files (import {f} from "./x.c"); clang reads them and the CLI builds and links them.
  • A function of an i32, u8, f32 or other narrow result that throws can be called as any other function.
  • giz fmt drops a needless ! (if (o !== undefined) { o! } becomes o).
  • giz test runs vitest and Bun test files (test, describe, expect), shows results as vitest does, and reruns on change with --watch.
  • The VM allocates objects and closures in compiled code, and runs min, max and int methods faster.
  • Python on the VM: operators on objects of two classes and isinstance run faster in compiled code.
  • giz ai gate holds a worker's outputs and time to recorded goldens.
  • Application.enhance(tag, script, style) adds a Web Component to a Pages app.
  • Auth functions take the app's Data.Db and fail with Model.Rejection; Auth.Site takes db, not store.
  • GizDB folds a GROUP BY of any aggregate by hash in passes, and spills to temporary pages only an input it cannot read again.
  • npm install -g @gizai/cli gives giz.ai's command line on every OS; the first Gizlang command installs the toolchain. The toolchain's giz no longer has giz.ai's account commands.
  • The VM runs mixed int and float Python arithmetic, array callbacks and JSON.stringify faster.
  • Python on the VM: ZeroDivisionError has CPython 3.15's message.
  • A new GizDB install answers TPC-H, ClickBench and SSB queries with compiled kernels from the first run.
  • An INSERT of a few thousand wide rows no longer fails with "staged transaction exceeds its admitted operation credit".
  • pg_stat_gizdb.kernel_misses counts statement parts that ran on the interpreter while their kernel compiled; the metric gizdb_wal_sync_seconds_total is now gizdb_wal_sync_ms_total, and gizdb_sessions_total and gizdb_checkpoints_total are new.
  • FlashHead lite talking-head videos run on the Gizlang worker (worker soulx-flashhead-lite).
  • The OmniVoice worker gives its free GPU memory back after each job.
  • H3 no longer refuses long videos that fit once blocks are staged to the host.
  • A lambda parameter that reuses the name of a local in scope reports E_SHADOW at the parameter.
  • giz live-generation emits a program once and reuses the optimized units of earlier builds.
  • Http.dataUrl(text) reads a base64 data URL: its media type and its bytes.
  • giz fmt no longer puts a space in a call of a member named of, in or another keyword.
  • app.rows(filter, values) and app.each(filter, handle, values) take the values of $1, $2, ... in the filter.
  • bin/giz test runs on a checkout with no build fleet again.
  • Each compile error code links, in the editor, to a table row that says how to fix it.
  • Auth.routes(site) adds email-link (and optional password) sign-in to a GizWeb app in one line.
  • giz says once a day when a newer @gizai/cli is out; GIZ_NO_UPDATE_CHECK=1 turns it off.
  • giz doctor checks your system, GPU, disk and network and says how to fix each problem.
  • The home page shows the app clip, and /sponsor takes crypto as well as cards.
  • giz test runs every file it is given, not only the first.
  • Chat agents take triggers that run them on a schedule or when you press Run.
  • TypeScript's fetch, process, node:fs, timers and new Promise work with no import.
  • giz prints a short first screen with examples; typos and missing files get a "did you mean" hint.
  • Python str.encode and bytes.decode accept every codec, such as UTF-16, UTF-32 and cp1252.
  • Python exceptions support add_note, builtin functions pickle, and int() accepts bytes.
  • Python array.array indexing, len and iteration are about ten times faster.
  • GizDB: a join or IN of a few keys over a table stored in key order runs up to 1.3 times faster.
  • GizDB: an ORDER BY ... LIMIT with a selective filter runs up to 1.6 times faster.
  • JavaScript on the VM: in sloppy mode, assigning to a frozen or read-only property is ignored, as in Node; strict mode still throws.
  • Python subclasses of C types such as array.array no longer crash the VM after many instances.
  • TypeScript without semicolons, JSON.parse results read with .x and [i], and const arrays at the top level that change with push.
  • GizDB: GROUP BY a small integer column runs up to 1.9 times faster.
  • A judged record's key can be any text, such as "user:1" or a URL.
  • giz python runs Python's command line (-c, -m, a script), and sys.executable runs it, so Python programs can start Python subprocesses.
  • OmniVoice's first voice clone after a start is as fast as the next.
  • GizDB: sums and averages over a whole column run up to 1.8 times faster.
  • TypeScript programs run as written: top-level statements, untyped void functions, integers as numbers, % on numbers, and main's number is the exit status (no longer printed).
  • GizWeb: a Pages app with DATABASE_URL set to a server or SQLite file explains the refusal instead of crashing.
  • GizDB: joins over stored tables run up to 15% faster.
  • Sponsors manage their sponsorship from a mailed link.
  • Python on the VM: sys.exit raises SystemExit, OSError(...) works, exceptions chain through __context__, and Python subclasses of C types such as io.TextIOWrapper run their own __init__.
  • GizDB from a release compiles its scan kernels: --only gizdb installs the toolchain for it.
  • Python's zlib, gzip, zipfile and sqlite3 work in the released toolchain.
  • GizDB: a LIKE query that aggregates matches each dictionary once.
  • An installed toolchain runs Python and Node programs with no git, compiler, system Python or Node on the host.
  • Visitors can sponsor Gizlang by card at /sponsor.
  • Python packages that bind built-in methods with __get__, such as attrs, import on the VM.
  • giz run of a JavaScript, TypeScript or Python file works with an installed toolchain.
  • A count of rows that match one filter reads each dictionary string once; ClickBench Q20 is 4.4 times faster.
  • Python programs with class hierarchies, super() calls and math or list built-ins run up to 2.4 times faster on the VM.
  • Joins with an OR over both tables filter each table first; TPC-H Q19 is 2.9 times faster.
  • The local chat example no longer runs out of memory when the agent draws and films at once on an AMD APU.
  • giz init prints the commands to run the new project.
  • Web.listen and bind listen on PORT when it is set, and a taken port says how to choose another.
  • giz live works from an installed toolchain without a system clang.
  • Batched UPDATEs by a list of primary keys run on the connection's thread, without the statement path.
  • giz build in a source checkout no longer runs out of memory in its ThinLTO link on many-core machines.
  • An embedded GizDB connection no longer stops the process when Conn.statement follows a Conn.run of another statement.
  • string.charAt no longer traps on non-ASCII text.
  • return undefined in a throwing function, A.B.f() through export * as B, and byte < 128 now check.
  • A failure caught with try/catch is no longer freed twice (it could corrupt memory).
  • Studio.video runs LTX-2.5 on AMD GPUs and downloads it on first use; gizhw:codec encodes H.264 through VA-API.
  • Chat components mirror on right-to-left pages and keep still for people who ask for reduced motion.
  • gizweb exports the auth row types and credentialAlg for migrations.
  • giz live serves an app's edited .ghtml pages without a restart.
  • .ghtml errors show the file's own line with a caret, and a missing field lists the record's fields.
  • gizdb Store.copy, Store.follow and Store.recount move a table into a stored type by key ranges, resumably, with a checksum.
  • GizDB no longer answers "no row" for an existing key read while updates of it wait for their sync.
  • A failed statement on an embedded gizdb:store folder no longer leaves the connection unusable.
  • current_database() and pg_database name the database the client connected to, so psql -d postgres and ORMs find it.
  • An I/O error that was "Unknown system error N", such as a full disk quota, now says what it is.
  • Passkeys also accept EdDSA and RS256 keys, not only ES256.
  • giz live runs apps of GHTML pages.
  • Optional chains work on field paths (a.b?.c).
  • a ?? b with an optional b is optional, as in TypeScript.
  • JSON.stringify of a record with an optional field no longer runs out of stack.
  • gizweb sign-in accepts bcrypt password hashes moved in from another system.
  • A web app on a port that another program serves stops with "port N is taken" instead of sharing its requests.
  • giz init todo --template todo creates a live app over a typed table.
  • The first use of a local model prints each download and the one-time conversion.
  • giz ai worker omnivoice serves OmniVoice text to speech.
  • LTX-2.5 video takes inputVideoStrength (0 to 1) for its first, last and injected frames.
  • GizWeb adds identity components (sign-in, account, members, teams, API tokens, devices) and the Auth namespace.
  • Reloading a live page many times no longer makes its app answer 500; a closed page frees its watches at once.
  • gizweb signs in with Google, GitHub and OpenID Connect providers, linked to people.
  • The JIT inlines array callbacks and closures. Stacks taken in inlined functions name every frame.
  • giz init my-chat --template chat creates a local AI chat app of agents, ready to run.
  • opt === v and opt !== v compare an optional value with a value, as in TypeScript.
  • A Pages app on GizDB starts after its record types gain fields: the new columns are added, and old rows read their defaults.
  • A component in a library may use a sibling component without an import, as in an app.
  • Fault reports name each frame's file:line in a stack, as Node does, with what failed or was thrown first.
  • A data connection shared by many tasks (a Pages app's handlers and background tasks) no longer refuses writes while another task's transaction is open.
  • An embedded gizdb:store folder answers a new session while another session runs a long read.
  • psql and PostgreSQL drivers get PostgreSQL's error texts for a missing relation and a NOT NULL violation.
  • A local AI chat app of agents in about 100 lines: gizweb:chat with plans, sub-agents, approvals, stop, model choice and attachments, and file inputs bound to page state.
  • gizweb signs in with passkeys (WebAuthn, ES256) and adds accounts with their own ids.
  • gizweb has accounts, sessions, teams, roles and API tokens (web/auth).
  • gizlang:cbor reads and writes CBOR (RFC 8949) values.
  • The VM runs using, DisposableStack and Intl (en-US) in JavaScript.
  • A parameter default may be any expression (children: Html = empty()); <C>kids</C> passes {} as the props.
  • giz lsp shows the outline of a file with an error, and hover and definition on what was checked.
  • giz lsp works on a fresh giz init project; "modules" in package.json is optional.
  • giz ai worker h3 --fl2va DIR --ref2va DIR --encoder HOST:PORT serves MiniMax H3 video, enhance-video and interpolate-video.
  • With --threads 2 or more, a GizDB server on a unix-domain socket alone answers other sessions while one runs a long statement.
  • giz ai image --model krea2-turbo takes --nag SCALE --negative TEXT.
  • gizweb:chat and <Chat> show an AI agent's run (text, reasoning, tool calls, files) live in a page, with the table as its memory.
  • giz ai image --model krea2-turbo takes --workflow edit, character-sheet, inpaint and outpaint.
  • type as a variable name, push of several items, () => voidCall(), for (let x of xs), and the message of a thrown record in fault reports.
  • Arrow functions take : T throws E, and an arrow passed where a function returning Result<T, E> is expected may just return T and call throwing functions.
  • gizdb Store, Data and Web.store functions throw their errors instead of returning a Result; write db.query(...) with no unwrap().
  • The VM no longer aborts on lone surrogates, and JSON and Python class code run faster.
  • ALTER TABLE ... ADD PRIMARY KEY on a very large table no longer runs the server out of memory: GizDB loads the table again in key order.
  • Pages.app serves a site over its own database and files, and examples/chat is a local AI chat with text, images and video.
  • giz help says that giz init makes main.giz, main.test.giz and package.json, and that giz live reloads on each save in the folder.

2026-10-22

  • Published benchmarks: GizDB runs ClickBench (10M rows) at 0.88 and TPC-H SF10 at 0.83 of DuckDB 1.5.6's time (geometric means, hot).
  • s.replace(a, b) replaces the first match of a string, as in TypeScript.
  • The README and the start guide install with npm and show what is built in.
  • giz run no longer hangs when another user on the machine ran giz first.
  • giz init projects keep running after you edit main.giz or add a file.
  • A fresh clone runs its tests (test data comes from gizai/gizlang-testdata), and bin/giz test runs a project's tests.
  • A program no longer stops with an out-of-memory fault while it holds dead values that came from another thread: the collector runs when the process nears GIZLANG_MEMORY_LIMIT.
  • The editor checks a file that the project does not import yet, instead of an error at its first line.
  • giz check hides library warnings, editors show the full error sentence, and a stale pin names its file and the fix.
  • x! of a value that is never absent, such as v[0]!, is the value, as in TypeScript.
  • giz ai serves Krea 2 Turbo (krea2-turbo), text to image in 8 steps.
  • SQL functions lists every SQL function that GizDB runs
  • GizDB refuses calls of SQL functions that do not exist or have the wrong number of arguments, instead of running a near name or stopping
  • Every Gizlang example in the documentation is a whole program that builds, and the docs tests check it.
  • import {open, connection} from "gizdb" now resolves: the gizdb library has a main module with the embedded API.
  • Every public declaration of the SDK and the libraries has a doc in the reference.
  • The reference shows the doc of the first declaration of each SDK module.
  • Markdown frontmatter values are JSON strings or plain YAML text; GitHub renders every docs page.
  • An image giz ai worker takes larger sizes: it counts the memory of the decode apart from the steps, and no longer refuses jobs that fit.
  • giz ai worker --id ID serves an image model under the model id ID; image requests take numberResults.
  • giz ai image --model z-image-turbo makes images with Z-Image Turbo (8 steps, not gated).
  • GizDB holds less memory for text that a client or a migration source sends: a stored text no longer keeps its parser's spare buffer.
  • With --threads above 1, a new connection no longer waits for a long statement on the loop that accepted it.
  • LTX-2.5 decodes 1080p videos on 24 GB cards and holds less host memory.
  • A program that faults exits at once, also with tasks, threads or GPU work still open, so a supervisor restarts it.
  • GizDB answers a read of a cold column that the memory left cannot hold with an error, where the server stopped.
  • Strings made from bytes and freed pages no longer hold spare memory, so bulk loads stay under the memory limit.
  • The docs check every link, list every setting and error code, and document the libraries gizdb, gizweb, gizfs, gizml and gizhw.
  • GizDB holds less memory for loaded text: a committed text no longer keeps a 256-byte buffer.
  • H3's text encoder conditions on pictures up to 1920 × 1088 on a 16 GB GPU.
  • Workers print each job's end and time; the LTX worker also prints each request's size and features.
  • Under gizdb cluster, current_database() and the catalogs name the database the connection selected.
  • A Task.parallel body that reads a captured let names it in the error and shows the fix.
  • A string has byte names (s.byteLength, s.byteAt(i), s.byteSlice(a, b), s.byteIndexOf(x)), and giz fmt --bytes moves code to them.
  • The documentation has one structure: tour, start, guides, operations, reference and internals.
  • The H3 worker's videos keep the detail of WanGP's (x264 crf 10 or NVENC 14).
  • H.264 encoding falls back to ffmpeg's libx264 when NVENC does not open.
  • LTX-2.5 control videos take edges (EVG).
  • Signing in to gizstack.com goes straight to your Giz account and back.
  • LTX-2.5 videos take the inpainting and outpainting workflows.
  • Memory.census(top) lists live heap objects by type and allocator blocks by size class.
  • H3's fp8mix video VAE loads; E4M3 weights without a scale are read as stored.
  • LTX-2.5 videos take control videos (raw and pose) and the ingredients workflow.
  • A run-time fault trace names the file of each frame, and giz test no longer shows a frame at another file's function of the same name.
  • A generic call such as newMap() takes its type arguments from the type expected where no argument gives them.
  • The compute and model modules are the library gizml (gizml:tensor, gizml:llm, ...) and the hardware modules are gizhw (gizhw:gpu, gizhw:kernel, ...); gizlang:machine stays in the standard library.
  • gizlang:video draws DWPose pose frames (pose, poseFrames), and gizlang:onnx runs convolutional networks (network).
  • LTX-2.5 videos take the fidelity decoder, and the quality mode takes a first frame.
  • neighborhood3d reads packed qkv rows and runs 7x faster; headPrepInPlace is public.
  • gizlang:netops has neighborhood3d, NATTEN-style 3D neighborhood attention on the GPU.
  • A fast live edit checks again only the function bodies it changed, through a resident compiler.
  • The LTX-2.5 video worker makes 20 s 1080p clips on 16 GB GPUs and supports automatic duration, quality mode, keyframes and soundtracks.
  • gizlang:worker can require a credential in the Authorization header (401 otherwise).
  • H3 runs ComfyUI's INT8 ConvRot and scaled FP8 checkpoints, and one worker serves FL2VA and Ref2VA.
  • GGUF Q4_K/Q6_K models run as stored, and NPU models chat and serve through gizlang:llm.
  • A live edit no longer writes per-edit files under build/; on a network file system an edit is about 10 times faster.
  • Fixed + on a Vec whose type is also compared with ===.
  • JSON.stringify and JSON.parse work on typed values (records, unions, arrays, Maps), and let x: T; declares a local without a value.
  • gizdb migrate copy reads a keyed StarRocks table in one streamed query: about twice as fast, and no sort of the rest of the table per page.
  • TypeScript's untagged unions (string | number) work, narrowed by typeof x === "string".
  • giz ai worker ltx2-5-distilled serves LTX-2.5 video generation (text, image, first and last frame, video extension).
  • Class instances are shared objects, as in TypeScript: every name of an instance sees a change, and === compares identity.
  • giz ai chat --cloud MODEL chats with any model of the GizStack AI Gateway on your Giz account.
  • LTX-2.5 requests start faster: rotary tables and 3D convs batched.
  • GizStack serves an OpenAI-compatible API (/v1/chat/completions, /v1/models) for every catalog model with an access key, billed to your team's credits.
  • giz live reports a program's errors at once on its first start, before it builds the libraries.
  • The NPU LLM reads a 621-token prompt in 1.26 s, as fast as FastFlowLM.
  • LTX-2.5 runs on Gizlang end to end, 13% faster than ComfyUI on a 16 GB card.
  • TypeScript generic classes, setters, regex literals, object types, Record, Partial/Pick/Omit, Array.from and Promise.all compile.
  • The NPU LLM (gizlang:npullm) reads a prompt in one pass: 621 tokens in 1.4 s in place of 25.6 s.
  • The agent's code mode answers again; tool calls from code no longer time out.
  • giz test with no argument runs the toolchain's suite only at the top of a Gizlang checkout.
  • TypeScript code needs no throws; module consts may be arrays and objects; as, readonly, Object.keys, new Set([..]) and Set spreads work.
  • Concurrent Task.parallel callers no longer wait for each other's pool threads.
  • Ready.channel() lets a server loop wait on a crossing channel and its connections together; Task.tryReceive() takes a value without waiting.
  • Task.Cell.close() gives a cell's memory back before the task that made it ends.
  • GIZLANG_RUNTIME_STATIC=1 gizstack build --fast always links the runtime statically, even after a build without it.

2026-10-21

  • gizlang:llm prefills Qwen3.5 prompts up to 6 times faster in the linear-attention layers.
  • gizlang:llm runs f8 models on the FP8 matrix cores of RTX 40 and 50 GPUs.
  • A large COPY into a server with a small memory limit no longer fails with an out-of-memory error.
  • GizDB runs MySQL and StarRocks date, JSON and max_by/min_by functions with their answers and types.
  • A large INSERT ... ON CONFLICT DO UPDATE of existing keys runs on all cores, faster than PostgreSQL.
  • A new SQL text is planned once instead of twice, and pg_stat_gizdb.plans counts the plans made.
  • Past the memory budget, a table that queries read keeps its columns in memory over a table no query read.
  • Live pages (Data.follow) read changes from the WAL journal; a watch holds no result state.
  • SELECT ... FROM read_csv(...) and the other file readers work on a server with --files, with LIMIT, WHERE and ORDER BY.
  • A single client's commit returns sooner: the log syncs without a hand-off between threads.
  • INSERT ... SELECT loads 2-5x faster on every core; a keyed load skips an ORDER BY no one sees.
  • GizDB commits pgjdbc transactions faster (TPC-C 64 clients +8%).
  • INSERT ... SELECT from a large table converts its rows on every core (2-3x faster).
  • CREATE TABLE AS on a server loads in chunks; large ones no longer fail at their credit.
  • GizDB answers SELECT ... FOR UPDATE by primary key without the statement path.
  • GizDB waits for a busy row's lock without running the statement again: about 25% more TPC-C throughput at 64 clients.
  • GizDB runs concurrent TPC-C writes to the same rows about twice as fast.
  • Queries that fix the leading columns of a composite primary key read only the matching keys.
  • Writes in pgjdbc transactions are answered by the connection's own thread before the engine applies them.
  • New connections are served while one long statement runs on the engine.
  • ALTER TABLE a SWAP WITH b exchanges two tables in one atomic catalog change.
  • ALTER TABLE ... RENAME TO outside a transaction block no longer rewrites the table.

2026-10-20

  • Image and video generation. gizlang:diffusion runs FLUX.3 klein (text to image, image edits and its prompt upsampler) and MiniMax H3 (text to video with sound, including its 4-bit W4A8 checkpoint as stored) on NVIDIA GPUs with INT8 matrix cores. An H3 request of 832 x 480, 124 frames and 6 steps takes about 31.5 s warm on one 16 GB RTX 4070 Ti SUPER; a FLUX.3 klein step at 1024 x 1024 takes 0.175 s on an RTX 4080 SUPER. Model.prepare makes a schedule's tables once for a long-running service. See Tensors, GPU kernels and AI models.
  • Shared operations for generative models in gizlang:tensor. attentionRows (attention over packed rows in BF16 or 8 bits, with the head norm and rotary in its quantizing pass), modulatedNorm (AdaLN), int8Rows and modulatedInt8RowsInto (rows rotated and quantized to INT8, fused with the norm), and lazyConv (3 x 3 convolutions whose patches the product reads as it copies). Kernels get Kernel.hadamard(..., regular) and Kernel.mmaHalf (8-bit products with F16 sums).
  • Language model servers. Engine.warm runs each first step shape before serve takes requests, so the first answer does not wait for kernels to compile. serve takes OpenAI tools and answers with tool_calls. Drafts run where they give tokens faster for that count of sequences (8 sequences on a 16 GB GPU: 395 tokens a second, was 228), and the KV pool of an engine of 4 slots on a 16 GB GPU holds 103.6K positions at 4 bits (was 49.2K), or 135.8K at 4-bit keys and 2-bit values (kv: "4/2").
  • FLUX.3 klein worker. serve-flux serves FLUX.3 klein (text to image and edits of up to four reference images) as an inference worker; gizlang:worker gains serve, invalid, failed, progress, uploadedImages and seed.

2026-10-19

  • Operators on your own types. An operator on a record calls its method of that name: a + b is a.add(b), and - * / < <= > >= and unary - call sub mul div lt le gt ge neg. Vectors, decimals and tiles read as math. See the language guide.
  • GPU kernels and language models. A new guide, Tensors, GPU kernels and AI models: tensors on the CPU and the GPU, your own kernels as tile programs that run on NVIDIA and AMD GPUs and on the CPU, gradients, and Qwen, Llama and Mistral models with gizlang:llm. Tensor.text() prints a tensor as nested lists.
  • lookup replaces lookup16. lookup(table, i) takes a table of any width and each index modulo its lane count: a u16x32 table is one vpermw, a u8x64 table one vpermb. Rename lookup16 to lookup; a 16-lane table works as before.
  • Faster batches of a few rows on AMD RDNA 3. On gfx11 GPUs a step of 2 to 32 rows reads 4-bit weights straight into the matrix cores: a 16-row step of Qwen3.8-27B on a Radeon 8060S takes 105 ms instead of 161, and decoding with MTP drafts runs at 33 tokens a second for one sequence (was 27) and 94 for four (was 71). Kernels get Kernel.shuffle (read any lane of the warp) and Kernel.mmaWords (an RDNA 3 matrix tile from registers).
  • Language models on the CPU draft too. An engine without a GPU drafts with the model's MTP layer as one on a GPU does, and its 4- and 6-bit layers read memory at its full speed: Qwen3.8-27B decodes 4.3 tokens a second on 8 Zen 4 cores, against 2.5.

2026-10-17

  • Permissions and the default app follow the model. A Data.Scoped (Data.as(db, space, actor, now)) reads and writes a Shape's rows as that actor may: the Policy is added to the query (a row without a grant is never selected), @Model.Read and @Model.Write set the role of a field, @Model.Within places a row below its parent, and a write is decided and placed in one transaction. Admin.admin now takes open (the actor of a request) and its list filters, sorts and pages in the database, shows reference labels and @Model.Computed fields, and lists the records that refer to a record; Admin.routes serves its actions too, so Admin.dispatch is gone. A key of an admin Shape may be an integer or several fields.

2026-10-16

  • No generated model files. Model.shape<T>() reads a record type while the program runs, so gizstack derive and the *.gen.giz files are gone. An app lists its actions with Model.action and Model.dispatch. See Model your data. The Memory.describe, Memory.flatten and Memory.unflatten functions read any type or value in the same way.

2026-10-13

  • Console addresses. Projects open at gizstack.com/{organization}/{project}/{area}. The old /o/... and /p/... addresses redirect permanently.
  • Hosted apps move to giz.sh. Apps and previews are served at {slug}.giz.sh. Old {slug}.gizstack.com addresses redirect permanently with their path and query.
  • Account recovery. Email verification and password reset by email.
  • Trust pages. Security, status, pricing and benchmarks.

2026-10-12

  • Developer preview. The Gizlang toolchain for Linux x86-64, the Playground, the documentation and the package registry.