Framework from a parallel reality where symbols won
In our world, computing evolved toward graphics, noise, and immediacy.
Interfaces grew brighter. Syntax grew heavier.
The act of programming became an act of telling machines what to do,
not understanding what things mean.
But imagine a world where theory, not graphics, led progress.
Where every machine spoke in symbols — quiet, precise, and alive.
Where the screen stayed monochrome, but thought itself became illuminated.
That is the world from which Symp arrived.
In Symp, every computation passes through two sacred stages:
This ritual — of checking form, then assigning meaning —
is the essence of all symbolic reasoning.
It’s how logic, language, and even mathematics work.
A frame is not a function. It is a conversation between form and meaning.
Together they form the Symp Triad — the systematically complete elements of symbolic computation.
Every piece of computation in Symp is expressed as a frame:
(FRAME
(SYNTAX <form>)
(SEMANTICS <meaning>))
When applied, it validates what is being said and interprets how it should behave.
Frames can be nested, chained, or even used to generate other frames.
This self-similar structure mirrors the recursion of thought itself.
To compute is to mirror meaning in structure, and to let structure reflect meaning back.
Symp is built on the idea of balance. Syntax and semantics exist in symmetry — one cannot dominate the other. Execution is merely the act of restoring that balance.
If an expression fails its syntax, it cannot be understood. If it passes syntax but lacks semantics, it has no meaning. When both align, computation happens naturally.
Every Symp component fits in a few hundred lines of code. Not by accident — but by intention. The system’s minimalism is its theology: to let form and meaning be visible, editable, and debuggable by thought alone.
Symp does not hide the machine. It invites you to see how it thinks.
Higher-order frames, when they appear, are not an accident — they are computation looking back at itself.
When (FRAME …) creates another frame,
Symp performs what could be called symbolic introspection:
the act of constructing new understanding from known understanding.
This is the boundary where code begins to resemble thought.
Symp is not a product of the modern computing lineage. It is an artifact — a fossil of an alternate evolution of symbolic machines.
In that world:
The machine itself is a mirror for thinking.
Symp does not compete with programming languages. It stands beneath them — a substrate for expressing them.
It reminds us that computation can be transparent, symbolic, and meaningful. That we can build software that is explorable by reason, not hidden by syntax.
Symp is not a better Lisp. It is what Lisp could have been if symbols had won the hardware race.
Every computation is a ritual of understanding.
Symp exists to make that ritual explicit.
In a world obsessed with output, Symp asks you to care about meaning.