Highly experimental. WeaveMark’s notation, Processor, examples, and public interfaces are still evolving — expect rough edges, surprising results, and breaking changes.

Readable, reusable, and composable prompts

Compose prompts like software. Read them like Markdown.

WeaveMark is a small, Markdown-native specification language for prompts: you specify abstract intent and the LLM-based processor makes it concrete (either by compilation or dynamic interpretation). The readable, reusable units you write in it are called promplets: each can stand alone or be built from other promplets. Great for both humans and AI agents.

Build your first promplet Understand the language Use from Python
ai-kanban-board.weavemark.md 
@promplet version: 0.7
@style "Implementation-ready, interaction-design-conscious."
  @refine module:weavemark.domains.programming.stacks.typescript_nextjs_prisma_sqlite mingle: true
  @refine module:weavemark.domains.programming.types.local_first_webapp mingle: true

  # AI Kanban

  Cards are live AI workspaces with plans,
  questions, outputs, activity, and review gates.

  @match output_surface_level
    "standard" ==> text, program, table, diff, status.
    "advanced" ==> add canvas, terminal, forms.
  @if realtime_updates
    Stream agent progress without losing board stability.
live cards AI workspaces, not sticky notes
output surfaces text, program, table, diff, status
local-first durable board state
50+ reusable method fragments — MECE, ACH, SCAMPER, chain-of-thought, and more
8 execution engines — tree-of-thought, self-consistency, reflection, weave, FSLM
1 → many one source compiles to prompts, packs, agent specs, or a running app
LLM-compiled abstract intent becomes concrete — largely LLM-based, deterministic structure where it helps

Why use promplets?

Readable prompts that grow through composition.

Promplets are clear to read, dense with intent, and safe to evolve. Templates fill blanks; WeaveMark gives you a composition surface for reusable promplets.

Read & evolve

Readable source that can mature.

The syntax stays minimally intrusive in Markdown. Keep important prompts in files, review changes, and track how behavior evolves without sacrificing readable prose.

Compose & vary

Reuse structure without copy-paste.

Refine shared reasoning methods and constraints, then branch with @if or @match when one source needs controlled variations.

Inspect & ship

Artifacts with an explicit destination.

See the compiled result, validate its contract, then produce a pastable prompt, prompt pack, agent specification, emitted file, or executable promplet.

Structural refinement

When templates are too shallow, refine structure.

The deeper move: one reusable promplet contributes ordering, obligations, and sections to different local prompts.

Worked example

Reusable structure plus local intent.

The source stays compact, while the compiled prompt gains the reusable decision structure in the right places.

Reusable structure Local intent Final compiled prompt
1. Reusable promplet to refine

Follow the cyan reusable obligations. They move into the final prompt as new structure around the local question. 

# Decision brief refinement

Every decision brief must:
- Lead with the decision pressure.
- Separate facts, assumptions, and judgment.
- Include counter-evidence and reversal triggers.

@output enforce: strict
  Return decision, evidence, counter-evidence,
  recommendation, and next action.
2. Local source

Follow the coral local values. They stay concrete while the reusable structure grows around them. 

@refine module:weavemark.std.lenses.decision_gate mingle: true

# Launch gate

Should we ship @{release}
to @{segment} this week?

Use @{validation_log}
and @{open_risks}.

@if executive_audience
  Compress into board-ready language.
3. Refined result after structural weaving

The same colors reappear below: cyan came from the reusable promplet, coral came from the local source. This is a composed prompt, not a filled form. 

# Launch gate

Should we ship Aurora 1.0
to beta teams this week?

Start with the decision pressure:
ship, wait, or narrow the rollout.

Use the validation log and
open risks, but separate
facts, assumptions, and judgment.

Include counter-evidence, reversal triggers,
recommendation, and the smallest safe next action.

Use board-ready language.

Batteries included

A library of reusable methods, not just syntax.

50+ reusable fragments across many categories. @refine them into your own promplets instead of re-deriving expertise — reasoning methods, programming stacks, teaching moves, and quality gates.

Reasoning & analysis
chain-of-thought MECE competing hypotheses issue trees strategic analysis decision gates
Ideation
SCAMPER Six Thinking Hats reverse brainstorming multi-persona debate
Programming
software-spec Next.js + SQLite decision dashboards workflow boards + focused modules
Teaching
Socratic tutoring misconception diagnosis mastery loops
Quality & safety
evidence quality finance safety research rigor release gates
Strategy & decisions
indirect strategy strategy selection forecast & uncertainty values tradeoffs

What can you build?

One language for many prompt systems.

Promplets are deliberately general: the same readable source style can describe pastable prompts, agent specifications, and executable promplets.

Language moves

Small directives, clear source.

Each directive has a local job: clarify, transform, branch, check, emit, or execute. The result is a promplet that still reads as a document.

Reusable obligations

@refine weaves reusable promplets into the current source when you need shared behavior. 

@refine module:weavemark.std.reasoning.deep_summary mingle: true
@refine module:weavemark.std.guidelines.evidence_quality mingle: true

# Leadership brief

Summarize @{notes} for @{audience}.
Preserve decisions, risks, evidence, gaps, and next actions.
Clarification point

@ask pauses compilation for missing human context, then continues with the nested body. 

@ask clarifying question detail_level: 30%
  @refine module:weavemark.std.teaching.socratic_tutoring mingle: true

  # Adaptive tutor

  Teach @{topic} using the learner context.
  Clarify who the learner is before compiling.
Iterative transformation

@iterate lets the Processor revisit a transformation instead of accepting the first useful expansion. 

@iterate 2
  @expand mode: intention focus: "playable first build"
    Metro Lines: draw routes through a living city,
    manage congestion, and validate the first playable loop.
Output contract

Assertions keep required content visible in the source before any assistant sees the final prompt. 

@assert contains: "risks"
@assert contains: "open questions"

# Review gate

Name the risk, missing information, and next step.

Using the output

Compile artifacts for the job you actually have.

Promplets are not only a nicer way to write one prompt. They can produce pastable prompts, programming-agent specifications, prompt packs, and prompts the WeaveMark Processor executes.

Executable promplets

When a prompt should run, make the runtime explicit.

Declare tool schemas, bind trusted companion implementations, and choose an execution engine — from a single call to tree-of-thought, self-consistency, or reflection, each modeled on established prompting patterns from the literature (Yao et al. 2023, Wang et al. 2022, Shinn & Madaan 2023). The readable document stays the specification everyone can inspect; when execution is requested, the selected engine interprets the compiled artifact at runtime.

tree-of-thought-solver.weavemark.md @execute 
@execute tree-of-thought
  max_depth: 3
  branching_factor: 3

Problem: @{problem}

@prompt thought_step
  Provide the next single reasoning step from @{state}.

@prompt evaluate_step
  Rate this partial reasoning: "sure", "maybe", or "impossible".

@prompt synthesize
  State the final answer from the best reasoning path.

Start here

Let the prompting begin.

Build one real promplet first. Then learn the directive moves, explore richer application domains, or jump to the API and reference as needed.

Start

Build your first promplet

Create a promplet from a blank page: add variables, borrow reusable constraints, branch, and lock the output shape.

  • Write readable Markdown.
  • Add reusable refinement.
  • Compile a concrete artifact.
Build your first promplet
Intro Mental model The language in plain terms. Why Principles The philosophy and design commitments. Learn Tutorial track Nine connected lessons, from first prompt to running app. API Use from Python Compile prompt specifications from applications. Ref Reference Exact syntax when you need it.

Live results

Play what a promplet produced.

These are real, checked-in browser projects generated through the WeaveMark compile-to-implementation workflow. Play them here, then inspect every source file and artifact on GitHub.

Strategy game

Transit City Swarm

Draw transit lines through a growing city, follow demand trails, and keep the network reliable.

Play live Browse source
Keyboard racing game

Orbital Drift

Use W/A/D or arrow keys to thread glowing gates, bend around gravity wells, and chase a faster two-lap time trial.

Play live Browse source