#>home_frame

Language as material. Structure as play. Systems that stay readable.

This site is a live workbench — every frame, operator, and brace has a job. Swap the leading sigil to change stance, swap the braces to change containment, and cycle mode to move between the surface, syntax, artifact, and Obsidian views. The side walls are clickable pivots.

Every character in <Spw> is a cognitive gesture: #> orients, ? opens inquiry, ~ reaches without binding, @ commits. Plain text becomes shared vocabulary for (people and tools alike) — a grammar that keeps structure legible at every scale.

The discipline behind this is applied learning science: how structure shapes what can be noticed, transferred, and accumulated across a group. The same operators that describe a software module also describe a learning sequence, a narrative session, or a research note. Legibility compounds: once the containment is visible, [parsing], [LSP], and [interactive rendering] are all variations on the same <attentional act>.

This site is a workbench for that question — one that rewards skeptics by staying plain and rewards practitioners by going deep. The surface is the argument.

Each line is a gesture in a grammar that stays readable as plain text. The operators are the vocabulary; the braces are the containment.

#>home_frame           < orients this unit of meaning
#:layer pragmatics     < qualifies the interpretive layer

^"focus"{              < elevates structured content
  ?[claim]             < probes without committing
  ~"obsidian"          < refers outward
  @publish             < commits a local action
  *feed                < connects dynamic content
}

&[context]{           < merges interpretive fields
  =label "learning"   < binds a name
  $meta               < reflects on the medium
  !pragma             < constrains the runtime
  %scale              < normalizes salience
  >surface            < projects a rendered view
}

$"cognitive_machine_map"

How To Read The Site

Start with the page in front of you, follow the handles when you want more. The left wall cycles density — the right wall cycles operator color. Each layer you unlock stays unlocked.

Fourteen operators. Top row: cognitive spine — orient, elevate, inquire, refer, act, flow, project. Bottom row: supporting grammar — qualify, settle, bind, reflect, integrate, normalize, constrain.

The brace is a polarity axis. The left wall { leans structural and shared; the right wall } leans situated and felt. Click either wall to cycle its register.

#>machine_register How the site works A field guide to frames, navigation, the console, the PWA shell, and the accessibility baseline. ?[operators] Every operator has semantics Read the symbols as a small vocabulary for structure, action, reference, and inspection. >pretext_physics Whimsy from measurement Try a live text layout probe where line wrapping becomes measurable and visible. @capture_frames Local media staging See how RPG notes can become private table tools for scenes, screenshots, and prompts. ^"motifs"{ Exploration rewards Motifs add optional texture after the core reading path is already clear.

*"media_focus"

Signal Register

Three-stage technical lifecycle: Source, Syntax, and Projection. — Source → syntax → projection. Every readable system has this lifecycle. The Spw grammar makes each stage inspectable.

The weekly focus is the current production thread. The daily focus is the entry door. Neither should feel like homework.

Weekly focus

$

Materials that teach by existing

The site itself is an argument for readable systems. Every frame, brace, and operator is doing something — and that something is legible.

Adjust the surface

Daily focus

?

One entry, infinite depth

A single route stays warm. Operators are the vocabulary; braces are the room. Walk in anywhere — you'll find the thread.

Enter the operator atlas

!threshold Quiet switchboard Adjust how visible the map, console, and scroll behavior should be in this browser. $dispatch Table brief Keep scene state, turns, clocks, notes, and session seeds close during play.

^"artifact_register"{

Artifact Register

These are the main entry points. Each one should give you a usable next step, not just another label.

#>craft_surface Craft Making web pages by hand. HTML, CSS, and SVG as creative materials for authors, illustrators, and anyone who treats files as play. #>public_spec Software surface Start here for Spw syntax, operator grammar, interactive codeblocks, and the Obsidian application context. #>rpg_wednesday RPG Wednesday A recurring tabletop session with a log, world notes, cast references, and local play tools. #>parser_runtime_tooling spw-workbench The TypeScript repository where the parser, runtime, LSP, and tooling ideas are developed. #>operator_atlas Spw operator atlas Use the atlas to learn each operator as syntax, interaction primitive, and future UI contract. #>website_field_guide Website field guide A reader-friendly tour of the site as an installable, inspectable publishing surface. #>author_craft Author craft Fragments, SVG motifs, file traditions, and screenshot prompts for writers exploring web pages. #>blog_input_interpreter Blog interpreter Turn Spw fragments, wonder notes, and rough drafts into local questions, outlines, and readable language seeds. #>language_docs spw.quest Language documentation for the grammar, examples, and projection model. >pretext_field_lab Pretext field lab A live probe for measuring text layout once and projecting it at multiple widths. #>surface_writing spwashi.ai Writing about surfaces, structure, registries, and ecosystem design.

#:language_field

Language as a field — not a format

Plain text as the trust surface

Readable files don't require a runtime to understand. Spw extends that: sections become named and queryable while the source stays inspectable. The vocabulary is the contract — no hidden state, no required toolchain.

Structure that indexes cleanly

Operators, layers, and references map directly to what LSP servers track. The same structure that helps a reader navigate helps a language server too — one grammar, two attention regimes.

Fragments that accumulate

Illustrators, painters, librarians, gardeners, engineers — a loose network sharing work across disciplines. When the form is legible, a drawing sent on Tuesday and a code edit sent on Friday speak the same grammar. Sessions become series; series become corpus. The vocabulary holds continuity without forcing uniformity.

Depth that scales with attention

Learning science calls this scaffolded access — the same structure that helps a beginner orient is the structure an expert reasons with. Parsers, renderers, schedulers are all reachable from ordinary language by anyone willing to follow the thread. That distance is the curriculum; the grammar is the scaffold.

?["operator_pivot_field"]

One concept, many stances

The operator that leads a term is a stance — a way of holding the same subject. Compare the same concept across operator perspectives to see what changes semantically when the sigil does.

a page

#>page frame A named container. The page becomes an address — it orients everything inside it. Other operators navigate to it; it doesn't navigate anywhere. #>page{ ... }

^"page" object A held instance. The quotes name it exactly; the caret says it is elevated, complete, inspectable as a thing that happened and will not unhappen. ^"page_v2"

?[page] probe An open question. What belongs on it? Who is it for? What counts as done? The bracket holds the question without closing it — inquiry without commitment. ?[page_scope]

*pages stream Pages as an ongoing practice — not one artifact but many in sequence, each a pulse. The asterisk follows the rhythm, not the instance. *pages > rendered

attention

?[attention] probe Attention as open inquiry — what is the learner noticing? Where does the inquiry land? The bracket holds the space without prescribing the answer. ?[attention_target]

>attention surface Attention as projection — what rises into view. Given this input, what becomes figure? What recedes to ground? The surface operator renders a salience map. >attention_surface

%attention normalize Attention as something calibrated — scaled to what's relevant. The percent sign says: attenuate noise, bring signal to a legible level. Salience is an engineering problem. %attention_weight

@attend action Attention as committed act — attending, not just noticing. The at-sign says: this is local, situated, done. You were present; something changed. @attend session

a voice

<voice> topic Voice as a topical lens — entering the subject of voice as a domain. The angle brackets bracket the topic, not the speaker. What you're looking through, not who you are. <voice> practice

^"voice" object A specific voice, held and named — this person's contribution, permanently real. The caret keeps it from dissolving into the collective. It happened; it has weight. ^"voice_narrator"

&[voices] merge Multiple voices as an integrative act — not harmony but coherence. The merge operator asks how separate interpretive fields contact each other without collapsing. &[voice_a, voice_b]

~voice ref A reference to a voice — pointing without speaking for it. The tilde reaches without claiming. You cite; you don't become. Distance is built into the sigil. ~voice_source

?["surface_register"]

Surface Register

Use this as the directory view after the main routes make sense: local pages first, then external work, domains, and ways to reach me.

On this site

recipes — culinary principles as substrate for novel culture; learning science applied to fermentation, mise en place, reduction
craft — author ramps for fragments, SVG motifs, file traditions, and book-site prompts
software — Spw syntax, grammar, interactive codeblocks
pretext lab — text layout without DOM reflow
website field guide — media-oriented tour of the site's PWA, frame, and Spw features
blog — local synthesis surface for Spw, wonder, rough notes, and future posts
rpg wednesday — recurring session log
about — systems, surfaces, direction