FUDGEL

Bija is the entire heap of a Fudgel application. It is the only place where state persists across function calls. All Rumus functions read from and write to Bija entities via Viesti signals.

At runtime, every human-readable name in a Bija file is discarded. The load-time pass assigns each entity and property a fixed memory offset. All subsequent references become raw pointer arithmetic.

The key distinction from general data formats like JSON is that Bija describes not just what exists, but how to derive everything else from it — purely through structure. Templates, instantiation, the multiplier, and positional overrides are all declarative derivations that resolve at parse time with no runtime cost.

Everything is entities and properties. Every property has exactly one value. Indentation denotes hierarchy. The parser has no type system, no logic, and no operations.

Values are always atomic. damage: #attack + 20 is a syntax error — Bija has no operators. If a value must be derived, that computation belongs in Rumus, and the result is written back to Bija by a Viesti signal.

All shorthand resolves at parse time. Commas, ! multipliers, positional pipes, boolean metadata — nothing from shorthand syntax survives into the PAF. The runtime sees only the fully expanded result.

References (#): A semantic alias — the compiler resolves it to the same address as the target and removes the reference. No indirection survives. Distinct from = (value equivalence), which copies the value at parse time and forgets the source.

Templates & Instantiation: NewThing: #TemplateName copies the referenced entity's full structure at parse time. Not a link — the copy is fully independent. Combine with positional overrides: Sword: #TemplateItem | 15, 3 |.

Multiplier (!): enemies: #Enemy !5 stamps out five fully independent instances at parse time, addressable as #enemies.0 through #enemies.4. Combinable with positional shorthand for homogeneous sets: wave: #Enemy !5 | 200, aggressive |.

Anonymous lists: The - marker creates an ordered list (numbered sub-entities, addressable by index). The * marker creates an unordered set (named sub-entities with empty values — the names are the data). Both resolve entirely at parse time.

Empty value: propertyName: empty is an explicit declaration. A property with no value is not null — it is empty by declaration. No inference occurs.

Metadata booleans ({}): health: 100 {required, immutable} expands to boolean sub-entities. Bija does not know what required or immutable mean — meaning is supplied entirely by the library that reads them during the compilation pass. There are no privileged metadata keywords.

Literals: propertyName: [literal text that may span multiple lines] — no parsing occurs inside square brackets.

File types — defined by imports:

Rumus is a pure transformation notation. A Rumus function takes named inputs, applies a transformation, exposes outputs. No side effects, no memory allocation, no loops, no branching. Every function is provably finite.

Rumus core is substrate-independent. It defines the minimum set of operations for Turing completeness with no numeric or hardware assumptions: bind (name a value), apply (pass a value to a function), compose (output feeds the next input), and select (produce one value from multiple candidates). What changes per target is the primitive operation set — the current working target is @rumus-riscv. A file targeting a different substrate imports a different target library. The Rumus functions themselves do not change.

There is no compiler optimisation pass. Performance is a direct product of design quality. The compiler's job is honest translation, not cleverness.

Five domains are available in any Rumus file without explicit import — the assumed baseline of computation. The @rumus-riscv target library maps these to RISC-V instructions.

Bitwise operations (& | ^ ~ >> <<) are hardware-specific and belong in a systems target library, not the standard set.

No loops. Rumus contains no loop syntax. Iteration is expressed as an explicit cycle in the Viesti signal graph, making it fully visible and schedulable.

Registers only. Functions operate exclusively in registers. Body property count directly determines register demand. A function body that exceeds available register capacity is undefined behaviour — the emitter does not spill, warn, or fail gracefully. Decompose the function.

Formal logic assertions. Operators like -> (implication) and !& (NAND / mutual exclusion) are not values — they are statements that must hold at function evaluation. Useful for state machines and invariants co-located with the logic they govern. An assertion failure names the function and the specific implication that broke.

Function address surface. The only externally addressable values on a Rumus entity are its parameter addresses and its ~ output addresses. All body properties are ephemeral and do not exist in the PAF. Viesti may only target these two kinds of addresses on a function entity.

Inline vs subroutine. A function called by a single caller is inlined at emit time. A function called by multiple callers is emitted as a subroutine. This is a determinism guarantee — inlining a function used by multiple callers would create independent register state at each site.

# inside Rumus is Viesti shorthand. A #Config.scaleFactor reference inside a function body is expanded at compile time to a compiler-generated Viesti signal that feeds the value as a new parameter. Rumus never reads Bija directly at runtime.

Viesti is the wiring of the application. It defines which data flows where. It does not compute. It does not store. It does not schedule. It routes.

Fudgel assumes everything happens instantly — no built-in run loop, no frame tick, no event queue. A Fudgel program is a one-shot execution: data exists in Bija, signals fire, functions run, results are written back to Bija. Recurring execution is a Lifga library concern. Viesti never knows time exists.

Signal order is execution order. Writing signals is simultaneously writing the execution schedule. Deterministic execution order is a direct consequence of file structure, not something the runtime computes or infers.

Three addresses and two tildes is the complete sequential form:

Pull model. A signal resolves when its source address has data available. The signal does not wait for a notification — it resolves when queried, and succeeds only if data is there. This applies equally to Bija source addresses and function output addresses.

Function execution gate: a Rumus function cannot execute until all of its parameter addresses have been populated by Viesti. If only some parameters are available, the signal does not fire — the condition is simply not yet met. No partial execution, no queuing, no error.

Dormant signals are not errors. A signal with no output target observes its source but routes nowhere. It is a compile-time known absence, absent from the execution graph entirely and visible as an unwired edge in the IDE graph.

The double tilde ~~ opens a parallel thread pool at the current execution depth. Signals declared under a ~~ are dispatched simultaneously to available threads. The main thread waits for all pools at the current depth before proceeding to the next sequential signal. The barrier is implicit — defined by indentation, not by any keyword.

~~ can also be chained inline: A ~~ B ~~ C dispatches A, B, and C in parallel. A single ~ anywhere in a chain is a barrier — everything before it must resolve first.

A ~~ is a claim about your program's semantics: these signals have no dependency on each other. The Peril library verifies this claim at compile time — it runs the pool's signals in both orderings against the fully expanded Bija state and compares outputs. If they differ, compilation halts with the conflicting signal path. Including @Peril means every ~~ in the application is compiler-verified rather than author-asserted.

Iteration is expressed as an explicit cycle in the Viesti graph. A signal targets a Bija entity that is itself the source of another signal, creating a feedback path. The termination condition is a Rumus function writing to a Bija boolean that downstream signals observe. The cycle is fully visible — declared by the author, seen by the runtime, no hidden looping.

Conditionals do not exist in Viesti syntax. A signal fires unconditionally when its source has data. Conditional branching is the result of a Rumus function writing to distinct Bija addresses based on its computation, with separate signals wired from each. Viesti routes from whichever address receives data. The decision was made inside Rumus.

Libraries are domain-scoped semantic abstractions that compile directly to Bija entities, Rumus functions, and Viesti signals. There is no distinction at the machine level between library code and author code. Libraries receive no special compiler access and carry no runtime overhead beyond what their compiled output requires.

A library is a Fudgel source file. There is no intermediate compiled format, no opaque binary. The source is the library. The conventional proprietary library model — distribute compiled output, withhold source — is architecturally impossible for the Fudgel ecosystem. Every library you import is readable and auditable by construction.

The @ declaration has one universal meaning: bring this into scope. The Trinity DSLs use exactly the same import syntax as domain libraries — there is no syntax distinction between a core import and an external one.

These libraries use Bija syntax for their declarations and run during the compiler's library pass stage, operating on the fully expanded application state before the PAF is emitted. They return the failing path if a claim cannot be verified — meaning most errors that would be runtime exceptions elsewhere are compiler errors in Fudgel.

The visual library stack has a clear division of responsibility. Kadro answers where and how big — pure spatial arithmetic, runs on CPU. Smink answers what does this look like — property resolution over the entity tree. Aquilla answers what is visible and in what order — a visibility and compositing pass that produces a resolved list of rectangular regions written directly to the framebuffer.

The result is invalidation-based rendering, not loop-based. Zero CPU is spent when nothing changes. Each layer is independently testable and replaceable.