Spw Reference Surface
Spw Operator Atlas
A sigil is useful when it changes what a reader knows how to do next.
Each operator is a small contract between text and tools. It tells a reader or runtime what kind of structure is present and how it can be inspected.
Operators are semantic actors; braces carry structural facts. The sigil tells you what kind of move is being made. The container tells you what kind of boundary or scope is being entered.
That makes Spw less like a secret code and more like compact notation for projection-based runtimes: nouns can hold variants, behaviors, and lenses; components can expose the same root under different display conditions; and familiar moves can recombine without every page explaining itself from zero. Returning learners can treat the atlas as a lookup table and a grammar practice room at the same time.
Familiar root
The repeated word or sigil is the stable grip. It should remain readable in plain text, markup, and screenshot.
Typed distinction
Brackets, braces, and lenses clarify whether a difference is variant, behavior, scope, or interpretation.
Combinatoric genre
Reusable operators can produce cards, scenes, prompts, runtime handles, and visual motifs from the same semantic family.
Boonhonk can act like a combinatoric genre: a pantry of reusable moves where a familiar ingredient changes meaning through preparation, timing, pairing, and presentation. The grammar should let a reader notice the difference between a variant, a behavior, and a lens without needing a lecture every time.
Sigils should stay learnable in plain text before they become interactive behavior.
You need to inspect the semantic shape of a move, not only its visual token.
Operator literacy, route handles, promptable syntax, and reusable semantics for future public pages.
One reason languages like this matter is that they can train anticipation. A typed statement can be subvocalized and checked for shape before it runs — the same "speech bubble metaphysical expertise" (l'n'd'r's clay golem magic) that turns operators into inner-speech rehearsal and attentional objects. That subvocalization resonates with cauldron priming (hold to gather), spell casting (replay the chain), and section-handle/resonance-probe refinements so the page echoes back matching operators across contexts. The same anticipation can spill outward into other literacies, including the more bodily ones around nutrition, chemistry, and weekly routine. Cauldron hook + visibility modes let you jump from a collected note to its living source on page and dial how prominently candidates appear while you practice the grammar.
It can also spill back toward math. One structural clue I want to keep public on this site is that integration by parts can be read as a boundary-aware rewrite: the handoff becomes explicit, the residue stays visible, and the remaining work moves elsewhere. That is why the differential lambda calculus bridge belongs near the atlas.
Operator Philosophy
The atlas is not only an index of tokens. It is a claim about how readers, tools, and future interfaces should generalize what a semantic move means. If you came here from another route, use the repeated tokens as anchors and the surrounding prose as the explanation of why they matter.
An opening brace or frame edge should bias toward entry, alignment, and local orientation. It marks where attention gathers.
Square-bracketed structures narrow what is being addressed so a reader or tool can compare, quote, or inspect a smaller region.
Parenthetical forms hold a temporary relation together without claiming a stronger projection or commitment than the text has earned.
A closing brace is where serialization, selection, or future projection can gather. It should feel like consolidation, not a dead ornament.
Projection is not a new source of truth. It is the same structure becoming visible in another room: page, panel, prompt, outline, or tool.
The public site should therefore translate plugin-shaped semantics into quieter interactions: enter the scope at the opening edge, inspect inside the body, and let the closing edge bias toward selection, serialization, or projection. Returning readers can keep the same tokens in view while the surrounding explanations get shorter.
Orient
Use the atlas as a field guide
- Return to the software surface#software The operator atlas is one layer inside the broader language design surface.
- Use the operator ring?ring The ring gives a compact orientation map before you go token by token.
- Enter the pretext lab.lab The lab keeps the atlas tied to experiments instead of leaving it as pure taxonomy.
Inspect
Inspect tokens as semantic actors
- Frame operator#> Naming a place is the first step toward shared human and machine navigation.
- Object operator^ Objects show how structured material can stay inspectable inside readable text.
- Probe operator? Inquiry operators are how a reader or tool asks more of the same source.
Commit
Separate action from projection
- Action operator@ Actions are local commitments and should feel different from later manifestations.
- Binding operator= Bindings pin names and categories so subsequent projections can stay faithful.
- Pragma operator! Constraints and forces belong to the local runtime contract before they show up elsewhere.
Project
Follow the block into another room
- Surface operator> This is the explicit projection move: the same structure rendered into another encounter. Web platform projections (see MDN CSS custom properties, Intersection Observer for attention flow) keep Spw faithful to browser substrate.
- Spw alchemistry>flow The alchemistry section shows how attention changes phase as it becomes stream or surface.
- Website publishing register>site The public website is one projection surface where these operator contracts remain visible.
Operators are verbs for readers and tools
An operator should not behave like a cosmetic badge or arbitrary feature switch. It should announce an intent that both a human reader and a machine reader can understand: inquire, refer, bind, commit, project, compare, normalize.
Braces carry topology
The operator says what kind of act is occurring. The brace says what kind of container receives that act. That separation keeps the language extensible: the same semantic move can appear in different substrates without confusing action and boundary.
Generalization should follow intent groups
For menus and public interfaces, it is often better to group operators by reader intent than by raw token list: orient, inspect, commit, compose, and project. That keeps the language teachable without flattening away its semantic distinctions.
Projection is not the same as action
An action commits a local change. A surface projects a structure into another encounter. Keeping those separate matters because authors need to know when they are deciding something and when they are manifesting it for another substrate.
The atlas should stay compatible with the plugin
I mostly meet Spw through the VS Code plugin and local workspace. The website atlas should therefore act as a faithful public guide to the same semantics instead of inventing a prettier but incompatible vocabulary for readers.
Good semantics reduce fake interactivity
If a token implies selection, projection, or scope change, the interface should have a credible action for it. Otherwise the public surface should stay quieter. The language model should sharpen expectations, not disappoint them.
Nearby Context
Surfaces already in contact with the atlas
- Software surface.surface The atlas is the smaller-scale grammar inside the broader readable-source argument.
- Pretext lab.lab Experiments keep the atlas connected to authoring rather than drifting into pure abstraction.
- Authoring seed.seed The seed shows how operator contracts can remain explicit inside one concrete block.
Subsequent Context
Where readers usually go after the thesis
- Operator ring#ring Once the philosophy is clear, readers usually want the compact comparison map.
- Action operator#action Separating local commitment from projection is one of the most important next distinctions.
- Surface operator#surface Projection semantics become more intuitive once the explicit surface contract is read closely.
Projected Context
How these contracts leave the atlas
- Website field guide>site The public site should teach the same semantics in a friendlier medium.
- Spw workbench>plugin The plugin and local workspace are denser projections of the same operator and brace logic.
- Blog surface>artifact Published fragments are where operator semantics prove they can survive outside a reference atlas.
Voice markers invite readers to try a stance.
Decorating language should not mean adding noise. A good marker gives the reader a small costume for attention: a way to read the sentence as question, artifact, spell, field note, rule, or scene.
# names the room
Use frame markers when a passage needs a place to stand: title, threshold, register, or route. The voice becomes more architectural.
? opens the aperture
Use probe markers when the reader should hold uncertainty instead of receiving a conclusion. The voice becomes curious, provisional, and generous.
~ keeps an echo nearby
Use reference markers for callbacks, memory, sources, and motifs. The voice becomes threaded rather than linear.
^ makes the phrase holdable
Use object markers when a phrase should feel like a card, talisman, specimen, or tool. The voice becomes more material.
@ asks for a move
Use action markers when language should become a ritual, instruction, edit, or invitation. The voice becomes more kinetic.
[] {} tune the costume
Use brackets for variants and braces for behavior: scene[comic]{soften}, note[field]{collect}, question[gentle]{return}.
Starts by naming the habitat, then asks the reader to notice one thing. Useful when the page should teach without sounding like a lecture.
Turns a sentence into a small replayable outcome. Useful when the reader should leave with a phrase, gesture, or artifact.
Keeps provenance visible while changing the material. Useful when the page should invite editing, comparison, and reuse.
The goal is not to make every sentence wear symbols. The goal is to develop taste: one marker can change the invitation, two can create a voice, and too many can turn the doorway back into a wall.
Sentence variety is nutrition for attention.
A run-on sentence often means the writer has more energy than container. The goal is not to punish that energy. The goal is to give it more shapes, so the reader can breathe, follow, and still feel the momentum.
The door opened. Use this when the reader needs a clear beat, a fact, or a landing place.
The door opened, and the room remembered us. Use this when two equal forces need to stand side by side.
Because the room remembered us, the door opened quietly. Use this when context should arrive before the action lands.
After the dust settled, after the shelves stopped shaking, after every label turned forward, the door opened. Use this when suspense should gather before release.
The room offered maps, jars, cards, keys, and one small bell. Use this when abundance matters, but the reader still needs order.
Then silence. Use this when the missing grammar is the point: shock, pause, afterimage, or emphasis.
The catalog wanted order, the children wanted dragons, and the librarian, who knew both needs were real, made a shelf for maps that could roar. Use this when several motives must stay visible.
A long sentence can work when each clause has a job, each turn changes the view, and the ending gives the reader a place to land.
newer writers often need more containers, not less imagination.
a draft has energy but every idea is arriving in the same sentence shape.
a page, scene, or paragraph with clearer pacing and more available voices.
A useful revision move is to mark the job of each sentence before rewriting it: #land, ?open, ~return, @move, .pause. Then vary the shapes until the paragraph has a pulse.
Structural Reduction Bridge
Spw is not the differential lambda calculus. It still benefits from the same kind of discipline: name the boundary, keep the resource movement explicit, and do not mistake a cleaner surface for a vanished obligation.
Workbench code gives this page a practical test: an operator should not only have a poetic name, it should carry a physics that can guide scanning, selection, replay, and composition. Measurement, potential, observer scope, merge pressure, value collapse, upward integration, constraint, measure, resonance, ground, and selector pressure are all partial moves in a larger calculus of attention.
That calculus is partial on purpose. A page, screenshot, prompt, or spell rarely transforms all at once. It composes by naming an input, applying a bounded operator, keeping the residue visible, and projecting the next state without pretending the hidden work disappeared.
Boundary-first reading
Good structure tells you where a block starts, what it depends on, and what residue survives after the local rewrite is finished.
anchor: operator philosophyWhy calculus belongs here
Integration by parts is a public example of the same structural move: expose the handoff, preserve the boundary term, and move the active differential burden.
route: calculus bridgeWhy resource sensitivity matters
Projection is not duplication. Interfaces, caches, rankings, and human attention all behave more honestly once duplication and displacement are named as costs.
route: differential lambda calculusWhy teams care
When a system gets simplified, someone still needs language for what dependency moved, what boundary stayed, and what work the new interface still carries.
route: algorithm visualizationOperator Ring
Use the ring as a compact comparison view. Every card gives you the token, the intent, and a route into the deeper operator page. The sequence doubles as a latent curriculum: resonance first, ground next, relation and possibility after that, then measurement, perspective, materialization, composition, constraints, surfaces, scenes, modes, and direction.
Spw Alchemistry
Transformation Model
Alchemistry is the transformation model for attention. Curiosity becomes a probe, relation becomes a reference, intention becomes action, action becomes stream, and structure becomes a surface only when the change remains inspectable.
Brace Physics
A brace marks where attention can gather without replacing the root. Opening { is objective boundary — shared structure you can inspect. Closing } is subjective synthesis — local consequence after traversal. Brackets [] hold discoverable variants; they are infix scopes, not postfix residue.
Charge may accumulate on entry and discharge on exit. Runtime phase and gesture charge are volatile; delimiter meaning is fixed.
Prefix / Infix / Postfix
Prefix primes before contact: !commit, ?ask, #>frame. Infix scopes the root: lens[probe]{wonder}, film[kitchen]{scene.metaphor}. Postfix marks residue after contact: commit!, closing }, settled ..
Fixity: delimiter grammar and data-spw-sigil-position are stable; capacity verbs are tending; data-spw-phase is volatile. Use @ for perspective, ! for action.
Future UI Surface
These pages are static first. Later, Spw blocks and scripts can use the same operator contracts to become widgets, inspect panels, spell boards, or LSP-backed navigation. When the semantics are explicit, the page can jump between the same root in different modes instead of flattening them into one label.
Cauldron workbench
This is a mounted experiment, not a finished product. The cauldron gathering system is public while it is still being worked on, and this bench tells you how to experiment with it, where to read its state, and what it becomes if the experiments keep landing.
? Invitation
You can try this right now: hold any charged term or brace target on this page and the cauldron begins gathering it as an ingredient.
! Experiment protocol
Tap a living term to prime it. Hold to capture it into the cauldron. Open the footer ingredients to see what you gathered; the cauldron hook jumps a captured note back to its living source on the page.
Everything is reversible and local: dismiss ingredients to reset, and nothing you gather leaves your browser.
. Reading surface
The experiment's state is inspectable: primed and candidate items respond to the cauldron visibility setting in settings, captured ingredients carry their origin context, and gesture charge is readable as data-spw-* attributes in your inspector.
& Elaboration path
Elaborate by remixing: gather a mix of ingredients that says something, screenshot it, or describe what you built through the contact path. Elaborations shape this atlas and the plan record that governs this bench — what previous readers built is part of what you are reading.
* Precipitation signal
Condition of arrival, not a deadline: when gathered mixes get shared back often enough to name a recurring shape, this experiment precipitates into a product form. The first named candidate is an operator deck — one card per sigil, with its motion, geometry, and symmetry partner.
$ Merchant path
Precipitates are sold by merchants in the community, not by this site — the site is the workshop and the reading room. The first stall stands in the town market. The standing invitation: elaborate a mounted technology until it precipitates, and the precipitate is yours to sell.
Semantic hierarchy
The site carries parallel ladders. Use the ladder that matches the question — do not collapse them into one flattened label.
Composition
page → region → feature → component → slot → module → chrome → runtime
Authored on body, data-spw-feature, data-spw-slot, and component anatomy. Runtime infers data-spw-composition-tier; it should not invent the public spine.
Expression
root[variant]{behavior}<lens> — root stays stable; brackets and braces narrow without replacing the stem.
Position + fixity
Prefix primes, infix scopes, postfix marks residue. Fixity runs cold → hot: fixed → stable → tending → experimental → volatile.
Grammar delimiters are fixed. Capacity verbs are tending. Phase and charge are volatile.
Cascade (presentation)
CSS layers resolve look, not meaning: reset → tokens → … → handles → effects → ornament. Semantic ownership stays in HTML, JS datasets, and .spw contracts.
Language evolution toward v0.4
Spw should become a compiler for meaning — not only readable text, but inspectable contracts that agents, editors, and tools can traverse without re-learning dialects per folder. The v0.4 direction is expressed here in public language; the inspectable pillar artifacts live in the site .spw layer and will precipitate upstream into the workbench submodule after review.
Essay-level conventions do not scale when agents must re-parse folder dialects on every pass.
You need to know what grammar, indexing, claims, or projection work is next — before the parser lands.
Profiles, typed references, executable probes, stem projections, precipitated indexes, and a pinned workbench spec.
The improvement stack is ordered deliberately. Profiles and validation come first so file shapes declare what blocks are required. Typed references and indexing make dispatch traversable and broken links diagnosable. Claim and probe syntax turns hypotheses into falsifiable checks. Stem projection carries the same root into HTML, CSS, JS, and .spw without forking truth. Precipitates and register serialization let indexes and manifests become language outputs rather than ad-hoc scripts.
Index, convention, pillar, plan-index, and wip-notebook profiles imply required blocks. Validation rejects drift before it spreads.
Typed ~" paths should resolve, project into indexes, and surface broken-link errors in CI — not only at read time.
owner_claim blocks carry hypothesis, spec_ref, impl_ref, probe_ref, and falsification — probes can run in validate-spw and check pipelines.
One stem can precipitate into page copy, tokens, runtime datasets, and inspection surfaces without inventing parallel vocabularies.
Plan indexes, agent manifests, and design catalogs should emit from register precipitates — not from one-off maintenance scripts alone.
Site pillars propose; spw-workbench on branch feature/spw-language-v04 proves. Pin the submodule after human review.
Priority stack
Profiles and validator → typed references → claim/probe syntax → stem projection → precipitate projections → register serialization → LSP lenses → grammar unification → runtime goals pipeline → core vs experimental namespace → submodule bridge.
Inspectable artifacts
Twelve pillar files under .spw/language/v04/pillars/ dispatch from .spw/language/v04/index.spw. Each pillar declares dimensions, owner_claim, language_delta, and validation probes.
Editor lenses
Dimension lenses, go-to-owner navigation, and claim overlays should make the same contracts visible in VS Code — not only on the public atlas.
What stays out of scope here
This section does not ship the v0.4 parser. It names the direction, keeps site and workbench aligned, and gives agents a stable reading order before upstream grammar lands.
Phase 1 (this site) lands pillar artifacts and public copy. Phase 2 ports contracts into docs/specs/spw/v04/ in the workbench and pins .spw/_workbench. Phase 3 precipitates stable stems into runtime checks and conventions. Read the plan at .agents/plans/spw-language-v04/ for sequencing detail.
Authoring Seed
#>spw_operator_page
#:surface #!reference
^"operator"{
token: "*"
intent: "flow"
interaction: "connect to dynamic or event-like content"
metaphysics: "attention becomes a current"
brace_physics: "stored charge biases the next projection toward motion"
}
?["What should tapping this operator reveal?"]{
fallback: "show the inspectable contract before any runtime action"
}The atlas starts as HTML, but the repeated structure is already shaped like something an authored Spw block could generate.