THE ZLANG OBSERVATORY
A language taking shape.
Streaming by nature. Responsive by design.
An independent language for fast applications and first-class zui.
Loading checkpoint…
Published snapshots · refreshes every 60sOn the workbench
IN PROGRESSLoading current work…
Browse checkpoint ↗PERFORMANCE LAB
Less work. Measured honestly.
Explore the cost of state updates, then compare generated code with Rust. Every result keeps its scope and source checkpoint.
One service. Different subscriptions.
How broad and granular invalidation trade CPU for memory.
Loading workload…
Update CPU
ns / frameMedian ± median absolute deviation
Retained heap
KiB · requested live Rust allocation bytes
Rust callbacks and native state tracking. Excludes GPUI rendering, Text, I/O and Zeron. This compares policies, not zlang against Rust.
All 8 workloads & measurement details
Making bursts cheaper
Before & after · skip subscriber walks when every view is already dirty
MEASURED CHANGE
No extra tracking metadata. One clean unrelated view disables this global shortcut; it does not solve general subtree rendering.
Refresh the mounts that changed
Two measured steps · coalesced wakes, then fewer child synchronization passes
Refresh CPU
µs / frameMedian ± MAD · not a confidence interval
Retained setup heap
KiBRequested live Rust bytes · not RSS
Actual mounted-tree adapter and native bindings. Mixed build profile: adapter/native/runtime optimized; other dependencies use the dev profile. Excludes GPUI layout, paint and whole-application performance. Comparisons were timed separately; do not multiply stage ratios.
All 31 workloads & source checkpoints
The cost of subtree caching
Experimental component rendering · direct renderer stays the default
Frame CPU
ms / requested frameMemory cost
Releasing removed layout contexts
Paired private dependency fix · separate from cache policy
Frame CPU
ms / requested frameMedian ± MAD · not a confidence interval
Retained requested heap
KiB after updatesThe fix drops contexts for removed layout nodes. Cached rendering still retains more heap than direct rendering. This is successful Rust allocator requests, not RSS or a whole-process memory limit; CPU results exclude GPU submission and rasterization. Neither cache promotion nor Rust parity follows from this ownership fix.
One record, independent field reads
Native Int cells · coarse revision, independent cells and a record cohort
Update CPU
ns / logical frameMedian ± MAD · not a confidence interval
Requested heap
Sparse subscriptions avoid unrelated evaluations; dense updates can cost more than coarse invalidation. Record aliases retain the whole record, while independent cell aliases have independent lifetimes. This measures Rust callbacks over flat Int fields, not generated components, Text, GPUI rendering or language parity. Dense writes update fields individually, not as an atomic batch.
Safer wake delivery, measured costs
Native state notifications · two separate paired studies
Native CPU
ns / iterationMedian ± MAD · not a confidence interval
Native memory
Each study uses its own paired baseline. Historical timings are never pooled across studies. Native callback costs exclude generated handlers, async scheduling, GPUI layout/paint, and whole-application Rust parity.
The cost of safe row lifetimes
Native key windows and removal validity · measured tradeoffs
Operation CPU
ns / operationMedian ± MAD · lower is better
Requested heap
Seven randomized paired rounds on one affinity CPU; setup and teardown are outside timing except registration churn. Allocation runs are separate. Registrations are validity guards, not expression watchers or rendered row scopes. Unchanged controls also vary; this is not a CPU win or service-driven UI benchmark. No generated repetition, GPUI layout/paint, GPU or Rust parity claim.
Measurement scope and retained adverse result
The initial inline map retained 368 bytes after its final registration. That original report remains in the private repository. Both final variants release empty map storage; lazy storage adds one 24-byte box while registered. More frequent release increases churn allocation traffic.
Two viewports, three rendering policies
Generated service rows · CPU and requested heap tradeoffs
CPU per iteration
Median ± MAD, not a confidence interval. Above 1× direct is slower.
Requested Rust heap
Instrumented stage calls across all measured iterations · left / right. Layout, prepaint and paint count pane boundaries, not every descendant. Scroll horizontally for all stages on small screens.
| Policy | Renders | Rows | Layout | Prepaint | Paint |
|---|
All three policies use the SAME fine-grained native dependency machinery. This compares renderer, cache and invalidation choices, not alternative native graphs. Actual manually driven headless GPUI layout, prepaint and paint are included; OS wake scheduling, GPU work and the surrounding parent visual tree are excluded. Requested Rust heap is instrumented separately from timing; it excludes RSS, C allocations and GPU memory. No equivalent Rust application baseline or language parity claim.
Frozen source and measurement scope
Snapshot JSON: raw samples, counters and source hashes ↗Reusing clean visible rows
Sparse wins, churn costs · measured CPU and retained memory
These timings measure the earlier cache: that version has an ancestor prepaint rollback defect. A separate corrected candidate passes retry tests, but its extra token and observer costs are not measured here. This cache remains experimental; corrected and adaptive performance acceptance is open.
Frame update CPU
µs / iterationMedian ± MAD · seven paired rounds
Memory cost
51 matched service cases preserve measured row geometry, values and native cleanup. Sparse 4096-row granular updates use about 0.325× CPU with 19,900 extra warm retained bytes. All-visible churn regresses to 1.057× CPU; the one-row sparse case shows no established win. Larger panes mount eight visible rows each. Dense changes the first row in each pane; all-visible changes all eight.
Headless GPUI layout/prepaint/scene work; excludes GPU rasterization and OS scheduling. CPU and requested Rust heap use separate binaries. Nine missing font families precede the fallback in this environment. This is neither an enabled optimization nor a Rust-parity result.
Study provenance
Where frame memory goes
Smaller temporary layout arrays · same service workload
Temporary Taffy layout arrays account for 84.6% of requested bytes in the large sparse granular case. Reserving smaller arrays reduces those bytes; it does not remove allocation calls.
Frame update CPU
µs / iterationMedian ± MAD · seven paired rounds
Memory cost
All 42 service cases preserve geometry, values and native cleanup; 840 differential layouts agree. CPU results are mixed, including small-view regressions and noisy unchanged controls. No retained-memory win is demonstrated. Dense updates change the first row in both panes, not every visible row.
Headless GPUI layout/prepaint/scene work; excludes GPU rasterization and OS scheduling. CPU and requested Rust heap use separate binaries. Nine missing font families precede the fallback in this environment. This is neither an enabled optimization nor a Rust-parity result.
Study provenance
What native collections actually cost
Production ABI · checked owners, stable rows and reactive identities
Operation CPU
ns / operationMedian ± MAD · lower is better
Requested heap
Five randomized paired rounds on one pinned CPU; setup, checksum and teardown are outside the timer. Allocation runs are separate. Indexed native reads include checked lookup plus row read; Vec/Deque use direct indexing and omit stable handles, shared ownership and subscriptions. Alias cases compare retain/release with Rc<Vec> clone/drop only. Native-only observer and Text lifetime probes remain in the raw snapshot. No compiler, async, GPUI or whole-application parity claim.
Finding the right collection storage
Paired storage prototypes · adverse results remain visible
Operation CPU
ns / operationMedian ± MAD · lower is better
Requested heap
Vec and VecDeque are lower-level Rust references: they preserve inline values and insertion identities, but omit shared ownership, reactive subscriptions and runtime schema/stale-handle checks. This is not a complete runtime parity comparison. The original prototype allocates temporary row values during append; the compact prototype uses borrowed scalar buffers. Wide middle moves benefit from moving keys instead of entire records. Text and subscription lifetime probes remain in the raw report.
zlang × Rust
Checkpoint microbenchmarks · time & allocations
Overall Rust parity remains open. Small UI differences are within measurement noise; these results do not measure a complete application.
Source provenance & limitations
THE ROAD AHEAD
A clear view of the work.
Tracked tasks, not a language completion percentage. The list grows as implementation and testing expose more work.
Language foundations
EVIDENCE, NOT ASSUMPTIONS
Built. Tested. Still being verified.
Passing tests cover the implemented subset. Whole-language Rust-equivalent safety and application performance remain unverified.
CHECKPOINT LOG