The values the Fuz stack is designed against

The purpose is human agency: software one can own, control, extend, and swap out. The values below are what a design is checked against on the way there. The Fuz intro post.

This page is a sketch. It draws the same data several ways, to choose which views are worth keeping. It names only projects on the Fuz stack page. What holds the values in place when agents write the code is on the coherence page.

Claude Fable 5.2 wrote this page and its data file. Its claims were checked against the repos on . The maintainer has not yet reviewed it.

The values

Each value is stated as a question to ask of a design, with a decision that passes it and where the stack falls short of it. The values are not one kind of thing, which is why no single ranked list holds them:

  • Gate It has to hold before anything else is weighed. correctness security worst case
  • Default The safe form is what happens unless someone asks otherwise. controllability
  • Objective It is pushed as far as it will go. speed startup
  • Budget It is free to spend until a limit is crossed. size memory
  • Overarching It applies to every choice and ranks nowhere. simplicity

Correctness

Ranked as
correctness Gate
Means
The software does what it says and nothing else, held to a reference where one exists.
Asks
What does this accept or produce that it should not?
Passes
  • fuz_schema's priorities, where a fix of over-acceptance goes ahead of speed and size
Falls short
Most projects have no outside reference to be held to, and where one exists the comparison often runs before a release and not on every change.

Security

Ranked as
security Gate
Means
Security is a constant priority, weighed in each design from the start. Code acts only on what it was handed, a misconfiguration with a security consequence fails loudly, and the behavior an attacker would probe is written as test suites that run against each backend.
Asks
What can this reach that it was not given?
Passes
  • gro's authority model, where the network is an import and no global carries authority
  • fuz_app's composable suites, which give an app built on it the attack-surface, adversarial-header, rate-limiting and data-exposure tests that fuz_app runs on itself
  • fuz_app's cross-backend tests, where one set of security cases, among them the credential ceiling, the privilege gates and login enumeration, runs over the wire against each backend
  • fuz_app's security reference, which names the attackers its auth stack is designed against
Falls short
gro's runtime says its security is not finished, and fuz_forge says its security is not ready to be trusted.

Performance

Ranked as
speed Objective startup Objective worst case Gate size Budget memory Budget
Means
Speed is pushed as far as it goes, size and memory are budgets that bind when crossed, and the time or memory an input can force is a limit, not an average.
Asks
Was it measured, on what, and against what?
Passes
Falls short
Energy and browser performance are never measured, and memory is gated in one place, the heap fuz_schema's schemas retain.

Controllability

Ranked as
controllability Default
Means
What the software can reach and what it will do are visible, reviewable and bounded before it acts, and doing more is a person's decision.
Asks
Where does a person read what this can do, and who decides when it does more?
Passes
Falls short
That library code takes its effects as parameters is a written rule, tested only over a named list of gro's own modules, and gro's policy file, the reviewable record of what a project may reach, is designed and not built.

Simplicity

Ranked as
simplicity Overarching
Means
Small enough to audit and to hold in one head: few dependencies, few concepts, one way to do a thing.
Asks
What did this design refuse?
Passes
  • gro's design, where staying simple and small is what keeps the surface small enough to audit
Falls short
Twin implementations, hand-written parsers and an owned runtime are complexity the stack chose to take on.

Method

A claim comes from a measurement, the measurement is published where the work loses too, and what was tried and declined is written down with its numbers.

Stated orders

Several projects state the order they weigh things in. Each column is one project's own list, highest first, in its own words. Items side by side are a stated tie, and a grey item is one this page does not track. Point at an item to find it in the other columns.

gro

  1. 1
    security
  2. 2
    web standards
  3. 3
    developer control and ergonomics
  4. 4
    speed, startup first
  5. 5
    binary sizememory

over all simple and small

gro's runtime design

tsv

  1. 1
    correctness
  2. 2
    speed
  3. 3
    binary sizememory usage
  4. 4
    extensibility, modularity, reusability

over all staying simple

The tsv README

fuz_schema

  1. 1
    correctness
  2. 2
    speedsize
  3. 3
    memory
  4. 4
    simplicity of the internals
  5. 5
    flexibility

fuz_schema's priorities

fuz

  1. 1
    security
  2. 2
    performance

fuz's values

fuz_code

  1. 1
    correct
  2. 2
    fast

fuz_code's guidelines

pglet

  1. 1
    sizestartup
  2. 2
    feature completeness

pglet's tradeoffs

By context

Within performance the usual order is speed, then size and memory. The situation changes it, and the documents say why each time.

WhereOrderWhySource
A tool that runs for a while speed > size = memoryThe usual order: speed first, then the binary and its memory.The tsv README
A short command, called in a loop startup > speed > size = memoryShort-lived runs dominate a loop an agent drives, so the start counts before the steady state.gro's runtime design
A library shipped to a browser speed = size > memoryBytes cross a network, so they rank with speed, and a written rule sets what speedup a byte must buy.fuz_schema's grading rules
WASM loaded by a page size > speedThe build is chosen by measurement per runtime, and where bundle size matters the small one is right.The WASM reference
WASM run by a host speed > sizeA host can spend bytes for speed where a browser bundle cannot.The WASM reference
Input a remote party wrote worst case > speed = size > memoryThe time or memory an input can force is ranked with correctness, ahead of speed and size.fuz_schema's priorities
A database for tests size = startup > speedpglet aims to beat PGlite on startup and size, and its throughput only has to stay within a factor of SQLite's.pglet's plan

Efficiency

Performance is the measured result a person feels, ranked by context. Efficiency is the stance under it: every cost names its reason, and the cheapest work is the work not done.

  • fuz_schema's priorities, where a feature not everyone needs is a separate export that bundles to nothing unused
  • gro's design, where the wins are startup, loading, caching and work avoided

Decisions

These are recorded decisions where one value was chosen over another. A row is what won and a column is what it won over. Where both cells of a pair are filled, the rows below say what the answer turned on: the context, which cost was meant, or a default.

won, overcorrectnesssecurityspeedworst casesizememorysimplicity
correctness
security
speed
worst case
size
memory
simplicity
ProjectWonOverChoseCostSource
fuz_schemacorrectnessspeedChecking every key of a strict object, where counting the keys was fasterA share of the time of every strict parsedeclined
fuz_codecorrectnessspeedA correctness gain is taken when it costs a few percent of lexing timeA few percent of lexing time, weighed against the gain only when an input would turn pathologicalguidelines
pgletcorrectnessspeedFloat text written digit for digit as PostgreSQL writes itA measured slowdown against the faster formattingtradeoffs
fuz_forgecorrectnesssimplicityA TypeScript server kept as the reference twin of the Rust one, held to it by shared testsTwo implementations to keep in stepoverview
fuz_appsecurityspeedA login for an unknown account still verifies a dummy password hash, so its timing matches a wrong passwordA password hash verified on every login for an unknown accountsecurity
zapsecurityspeedSecurity controls are read from the live machine on every run, with no cacheEvery plan reads them again instead of trusting a stored verdictsecurity
fuz_schemaworst casesizeAn issue path that stays linear on deep inputThe bytes a smaller path-copying form would have saveddeclined
grospeedsecurityOne realm, mutable intrinsics and the JIT on by defaultSome hardening, which an opt-in tier listed as future work would give backruntime design
tsvspeedsizeProfile-guided builds for the shipped CLI and native addonLarger binariesperformance
blake3sizespeedA second build without SIMD, about 30% smaller, for where bundle size matters moreIn that build, the two to three times SIMD gains on large inputsinstall
fuz_schemaspeedmemoryA lowercase conversion that always copies, where skipping the copy allocated lessAn allocation per parse, since allocation only breaks tiesdeclined
fuz_schemamemoryspeedNo lookup table held by each object schema, where one made some checks fasterThe faster lookup on input out of the schema orderdeclined
tsvspeedsimplicityA cleanup of a hot path is measured like any change, and refused when it costs timeCode that stays less tidy than it could beperformance

What a reader can verify

What a reader can check about what the stack publishes without taking the publisher's word. Each check rests on the one before it, and each is listed with where it is built and what it does not yet cover.

CheckWhat passing it showsWhere it is builtWhat it does not cover yet
Content addressingThe bytes in hand are the bytes that were named. An artifact is identified by the BLAKE3 hash of its content, so a changed artifact no longer matches its name.
SigningThe bytes came from a holder of the publisher's key, whichever server delivered them.
  • fuz checks a release's Ed25519 signature against keys built into the binary, and the installing side links verification only, never the code that signs
  • fuz's verification flow checks the manifest's signature before any release bytes are fetched, then the hash of the tarball and of each binary, and stops at the first failure
  • fuz_forge's fuzf tool publish signs an artifact with the publisher's key, which the forge never holds
  • fuz's docs list the hosted install channel as not yet there: nothing is published to fetch
  • On a binary install the built-in key is the root: trusting the first binary means trusting every later release that key signs
  • fuz_forge has no published release, and the install it documents checks a SHA-512 file, not a signature
Reproducible buildsThe binary is what the source builds: two builds of one commit come out the same, byte for byte.
  • gro's snapshot build of fgro is reproducible from any path, given the same toolchain and cargo home
  • The comparison that holds gro's build in CI is a row of the oracle table
  • fuz has fuz artifact build --verify, which rebuilds and compares the output hashes
Release logThe release is the one everyone else was shown, and its publisher has not withdrawn it.
  • fuz's release log check reads one signed, append-only list of releases from every configured witness, and requires the release to be a row of it with the same hashes, not revoked
  • Publishing with a log repository named records the release in that list
  • The check is implemented and inactive by default: no public release log exists, and nothing happens unless the address of one is set
  • Its limits: a bad release becomes public and permanent and is not prevented, and a witness serving an old list hides a newer withdrawal