+==============================================================================+
| |
| FUNGUS ASTRONAUTICUS |
| ESOTERIC 3D FUNGEOID SPECIFICATION |
| APOLLO-ERA COMPUTING MODEL |
| |
+==============================================================================+
Fungus Astronauticus is an esoteric "3D fungeoid" programming language, inspired
by Apollo-era computing. It combines spatial execution (as in Befunge) with a
strict hexadecimal, byte-oriented opcode model.
It's a "space pioneers" language: small vocabulary, deterministic execution,
explicit control flow, and no hidden runtime structures beyond what an
Instruction Pointer (IP) physically carries.
--------------------------------------------------------------------------------
========
OVERVIEW
========
Fungus Astronauticus operates on:
- An horizontally unbounded 3D program space of single-byte opcode IDs,
- Multiple concurrent Instruction Pointers (IP),
- One data stack per IP,
- One return stack per IP
Each cell stores a single byte: 0x00 is reserved for VOID (empty space), and
executable opcodes occupy 0x01-0xFF. The high hexadecimal nibble (0x0-0xF)
defines the instruction category.
Directions are ordered clockwise: north, east, south, west.
--------------------------------------------------------------------------------
=============
NUMERIC MODEL
=============
Cell values are signed 64-bit integers (2's complement) stored on the data
stack.
Determinism:
- All integer arithmetic wraps modulo 2^64 (no traps).
- Division and modulo by zero yield 0 (as specified in 0x3_).
Fixed-point convention: Q32.32.
- A fixed-point value represents raw / 2^32.
- The number of fractional bits is F = 32.
Angle convention: fixed-point turns.
- 1.0 turn represents one full revolution.
- Angles are stored in the same Q32.32 format as other fixed-point values.
--------------------------------------------------------------------------------
=============
IP SCHEDULING
=============
At each execution step of the grid, every IP executes the instruction it is
pointing to, and moves to the next one.
IP's execution order is sequential, in choronological order of creation. All
effects of the execution of an IP are applied immediately, before execution of
the next IP in the sequence.
--------------------------------------------------------------------------------
==============
SECURITY ZONES
==============
The grid is partitioned into intrinsic security zones. Each cell belongs to a
zone with a security level (sec-level) between 0 (low-sec) and 6 (high-sec).
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
------------------------
IP sec-level inheritance
------------------------
When an IP is spawned, it inherits the sec-level of the zone containing its
spawn cell. This sec-level becomes part of the IP state.
The D instruction decrements (by 1) the security level of the IP executing it.
There is no instruction to increment it.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
---------------------
Non-interference rule
---------------------
When an IP executes an instruction located in a zone with sec-level lower than
the IP's own sec-level, that instruction may produce world effects (for example
spawning IPs or writing to the grid), but it can never change the IP's internal
state.
The IP's internal state includes:
- Its position,
- Its direction,
- The data stack,
- A return stack,
- An extended-mode flag,
- A shadow-memory flag.
Implementations should treat such lower-sec instructions as read-only with
respect to the IP state.
When an attempt to modify the IP's state fails because of the security context,
the IP's state stays unchanged. Any other effect of the instruction is applied.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
---------------
Altitude gating
---------------
An IP's reachable Z range is limited by its sec-level.
- An IP with sec-level SL may only occupy altitudes Z in [0..SL].
- Attempts to shift outside this range using u or d have no effect.
This provides a secure, non-world-changing channel between high-sec zones by
using higher Z layers that low-sec IPs cannot reach.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
----------------------------
Shadow memory layer (Z = -1)
----------------------------
In addition to the "executable land" (Z >= 0), the grid includes a non-
executable shadow memory layer at Z = -1.
- No IP can ever occupy Z = -1 (attempting to move down from Z = 0 using d
does nothing)
- Cells at Z = -1 are never executed as instructions.
- The shadow layer can be used to store and retrieve code/data spatially without
modifying the executable land.
Shadow-memory access is performed using a one-shot modifier instruction m (see
category 0x0_) that applies to the next meta instruction only.
Extended-opcode access is performed using a one-shot modifier instruction x (see
category 0x0_) that applies to the next instruction only.
--------------------------------------------------------------------------------
===========================
INSTRUCTION SET BY CATEGORY
===========================
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
--------------------------
0x0_ - Code as Data / Meta
--------------------------
+------+-------+--------------+------------------------------------------------+
| ID | Glyph | Name | Description |
+======+=======+==============+================================================+
| 0x01 | ` | NOP | No operation |
+-----=+-------+--------------+------------------------------------------------+
| 0x02 | ' | Local read | One-shot: next cell opcode ID will be pushed |
| | | | but not executed |
+------+-------+--------------+------------------------------------------------+
| 0x03 | " | Zone read | Push opcode IDs until next " (delimiters |
| | | | included; ( and ) pushed and executed) |
+------+-------+--------------+------------------------------------------------+
| 0x04 | g | Get | Pop y,x; push opcode at [x,y,z_ip] |
+------+-------+--------------+------------------------------------------------+
| 0x05 | p | Put | Pop y,x,v; write opcode v at [x,y,z_ip] |
+------+-------+--------------+------------------------------------------------+
| 0x06 | , | Local write | Pop v; overwrite previous cell (opposite |
| | | | direction) |
+------+-------+--------------+------------------------------------------------+
| 0x07 | _ | Zone write | Pop and paste until " delimiter (consumed, not |
| | | | written; ( and ) written and executed) |
+------+-------+--------------+------------------------------------------------+
| 0x08 | m | Mem Mod | One-shot: the next meta instruction operates |
| | | | on z = -1 instead of Z = z_ip; no effect on |
| | | | non-meta instructions |
+------+-------+--------------+------------------------------------------------+
| 0x09 | ? | Reflect IP | Push IP state onto the data stack |
+------+-------+--------------+------------------------------------------------+
| 0x0A | x | Extended | One-shot: decode and execute the next executed |
| | | | instruction using the extended opcode table |
+------+-------+--------------+------------------------------------------------+
| 0x0B | D | Downgrade | Decrement the security level of the IP |
+------+-------+--------------+------------------------------------------------+
0x00 is VOID. VOID is 0x00. It is just empty space.
Fetch rule: when an IP is about to execute, it reads the byte at its current
position. If that byte is 0x00 (VOID), the IP advances one cell forward (in its
current direction) and repeats this check until it reaches a non-VOID cell. Then
it executes the opcode there.
NOP (0x01) is different: it is an explicit instruction that consumes one
execution step and produces no effects.
Meta instructions are: ' " g p , _.
When preceded by m, these meta instructions read/write the shadow memory layer
(Z = -1) instead of executable land (Z = z_ip).
When preceded by x, the next executed instruction is decoded via an extended
opcode table instead of the base instruction table. The x modifier is one-shot.
The "next executed" instruction is the one that would be executed next if x were
NOP at the same coordinate (i.e., after applying the usual control-flow,
bridges, skips, and direction semantics). Then x causes that instruction to be
decoded using the extended table and executed immediately. Then control
continues as if that instruction had been executed normally.
So an extended instruction occupies two consecutive execution slots, not
necessarily two adjacent cells in program space.
x is one-shot and never compounds. It affects exactly one executed instruction.
If x targets a cell whose glyph is also x, that targeted cell is decoded using
the extended table like any other glyph. It does not trigger another extension
pass.
? pushes the following values (topmost last):
- sec_level
- x
- y
- z
- dir (0=north, 1=east, 2=south, 3=west)
- data_stack_depth
- return_stack_depth
--- Unassigned glyph policy ---
- Any printable/typable character that has no assigned meaning in the active
decode table (base or extended) is ignored and behaves as VOID (0x00).
- This rule applies to the operand selected by x as well.
In other words, an unassigned glyph is always treated as if the cell contained
0x00, so it is skipped by the VOID fetch rule and does not consume an execution
step.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-------------------------------------
0x1_ - Hexadecimal Digit Accumulation
-------------------------------------
+-----------+---------+--------------------------------------------------------+
| ID range | Glyphs | Description |
+===========+=========+========================================================+
| 0x10-0x1F | 0-9 A-F | top = top * 16 + digit |
+-----------+---------+--------------------------------------------------------+
Hex constants are built by first pushing zero (.).
Example:
.FF4A08 ; builds 0xFF4A08
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-----------------------
0x2_ - Stack Operations
-----------------------
+------+-------+---------------------------------------------------------------+
| ID | Glyph | Description |
+======+=======+===============================================================+
| 0x20 | . | Push new 0 |
+------+-------+---------------------------------------------------------------+
| 0x21 | : | Duplicate top (0 if empty) |
+------+-------+---------------------------------------------------------------+
| 0x22 | \ | Swap top two (missing values treated as 0) |
+------+-------+---------------------------------------------------------------+
| 0x23 | ~ | Pop (discard top) |
+------+-------+---------------------------------------------------------------+
| 0x24 | o | OVER: a b -> a b a |
+------+-------+---------------------------------------------------------------+
| 0x25 | c | ROT: a b c -> b c a |
+------+-------+---------------------------------------------------------------+
| 0x26 | b | -ROT: a b c -> c a b |
+------+-------+---------------------------------------------------------------+
| 0x27 | i | NIP: a b -> b |
+------+-------+---------------------------------------------------------------+
| 0x28 | t | TUCK: a b -> b a b |
+------+-------+---------------------------------------------------------------+
| 0x29 | a | 2DUP: a b -> a b a b |
+------+-------+---------------------------------------------------------------+
| 0x2A | z | 2DROP: a b -> (drop both) |
+------+-------+---------------------------------------------------------------+
| 0x2B | j | 2SWAP: a b c d -> c d a b |
+------+-------+---------------------------------------------------------------+
| 0x2C | q | 2OVER: a b c d -> a b c d a b |
+------+-------+---------------------------------------------------------------+
| 0x2D | k | PICK: pop n; copy nth item from top (0=top) |
+------+-------+---------------------------------------------------------------+
| 0x2E | l | ROLL: pop n; move nth item to top (rotating segment) |
+------+-------+---------------------------------------------------------------+
| 0x2F | X | CLEAR: empty the stack |
+------+-------+---------------------------------------------------------------+
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-------------------------------------
0x3_ - Arithmetic and Logic Operators
-------------------------------------
+------+-------+---------------------------------------------------------------+
| ID | Glyph | Description |
+======+=======+===============================================================+
| 0x30 | + | Push b+a |
+------+-------+---------------------------------------------------------------+
| 0x31 | - | Push b-a |
+------+-------+---------------------------------------------------------------+
| 0x32 | * | Push b*a |
+------+-------+---------------------------------------------------------------+
| 0x33 | / | Integer division (0 if divide by 0) |
+------+-------+---------------------------------------------------------------+
| 0x34 | % | Modulo (0 if modulo by 0) |
+------+-------+---------------------------------------------------------------+
| 0x35 | ! | Push 1 if a==0 else 0 |
+------+-------+---------------------------------------------------------------+
| 0x36 | & | Boolean AND |
+------+-------+---------------------------------------------------------------+
| 0x37 | | | Boolean OR |
+------+-------+---------------------------------------------------------------+
| 0x38 | > | Push 1 if b>a else 0 |
+------+-------+---------------------------------------------------------------+
| 0x39 | < | Push 1 if b<a else 0 |
+------+-------+---------------------------------------------------------------+
| 0x3A | = | Push 1 if b==a else 0 |
+------+-------+---------------------------------------------------------------+
| 0x3B | G | Push 1 if b>=a else 0 |
+------+-------+---------------------------------------------------------------+
| 0x3C | L | Push 1 if b<=a else 0 |
+------+-------+---------------------------------------------------------------+
0 = false, non-zero = true.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
--------------------------
0x4_ - Motion and Rotation
--------------------------
Motion operators modify the IP's direction delta rather than teleporting the IP.
- n e s w set the direction delta to a cardinal direction.
- After each instruction executes, the IP advances one cell in its current
direction (including after n e s w).
- When on an empty cell, the IP jumps directly to the next non-empty cell in its
current direction.
- If there's no more non-empty cells in that direction, the IP line-wraps (jumps
to the last non-empty cell in the opposite direction). When a direction has no
non-empty cell in that line (forwards or backwards), the IP is terminated.
- Unlike many fungeoids, u and d do NOT change direction, they only increment
and decrement the IP's current altitude.
+------+-------+---------------------------------------------------------------+
| ID | Glyph | Description |
+======+=======+===============================================================+
| 0x40 | n | Set direction to north (-y) |
+------+-------+---------------------------------------------------------------+
| 0x41 | e | Set direction to east (+x) |
+------+-------+---------------------------------------------------------------+
| 0x42 | s | Set direction to south (+y) |
+------+-------+---------------------------------------------------------------+
| 0x43 | w | Set direction to west (-x) |
+------+-------+---------------------------------------------------------------+
| 0x44 | u | Shift up one layer (z = z+1, gated by sec) |
+------+-------+---------------------------------------------------------------+
| 0x45 | d | Shift down one layer (z = z-1, gated by sec) |
+------+-------+---------------------------------------------------------------+
| 0x46 | r | Reverse direction (north <=> south, east <=> west) |
+------+-------+---------------------------------------------------------------+
| 0x47 | ( | Rotate right (clockwise) |
+------+-------+---------------------------------------------------------------+
| 0x48 | ) | Rotate left (counterclockwise) |
+------+-------+---------------------------------------------------------------+
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-------------------
0x5_ - Control Flow
-------------------
+------+-------+---------------------------------------------------------------+
| ID | Glyph | Description |
+======+=======+===============================================================+
| 0x50 | # | Bridge (skip next cell) |
+------+-------+---------------------------------------------------------------+
| 0x51 | ; | Jump over until next ; |
+------+-------+---------------------------------------------------------------+
| 0x52 | $ | Split instruction pointer (one does r and one does NOP) |
+------+-------+---------------------------------------------------------------+
| 0x53 | @ | Call |
+------+-------+---------------------------------------------------------------+
| 0x54 | ^ | Return |
+------+-------+---------------------------------------------------------------+
| 0x55 | [ | Conditional rotate (pop a; if a==0 rotate left else rotate |
| | | right) |
+------+-------+---------------------------------------------------------------+
| 0x56 | ] | Conditional rotate (pop a; if a==0 rotate right else rotate |
| | | left) |
+------+-------+---------------------------------------------------------------+
--- Call semantics ---
- The @ does:
- Pop dir, y, x
- Push return frame (x_at, y_at, z_at, dir_at)
- Jump to (x, y, z_ip) and sets direction to dir
- The ^ does:
- Pop and restore frame and advances one step
- Nothing if return stack is empty
Direction encoding:
+----------+--------------------+
| Value | Direction |
+==========+====================+
| 0 | north |
+----------+--------------------+
| 1 | east |
+----------+--------------------+
| 2 | south |
+----------+--------------------+
| 3 | west |
+----------+--------------------+
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
---------------------------------------------------------
0x6_ - Extended Numeric and Fixed-Point Operators (via x)
---------------------------------------------------------
These operators are accessed using the one-shot x modifier and decoded through
the extended opcode table.
Assumed fixed-point convention: Q32.32 (F = 32), defined in Numeric Model
section.
+------+---------+--------+----------------------------------------------------+
| ID | x+Glyph | Name | Description |
+======+=========+========+====================================================+
| 0x60 | x* | FMUL | Fixed multiply: (b*a)>>F using wide intermediate |
+------+---------+--------+----------------------------------------------------|
| 0x61 | x/ | FDIV | Fixed divide: (b<<F)/a (0 if a==0) |
+------+---------+--------+----------------------------------------------------+
| 0x62 | x+ | FADD | Fixed add: b+a |
+------+---------+--------+----------------------------------------------------+
| 0x63 | x- | FSUB | Fixed subtract: b-a |
+------+---------+--------+----------------------------------------------------+
| 0x64 | x~ | FNEG | Fixed negate: -a |
+------+---------+--------+----------------------------------------------------+
| 0x65 | xs | ISQRT | Integer square root (0 if a < 0) |
+------+---------+--------+----------------------------------------------------+
| 0x66 | xd | DIVMOD | b a -> q r (0,0 if a==0) |
+------+---------+--------+----------------------------------------------------+
| 0x67 | xh | MULHIU | High 64 bits of unsigned product |
+------+---------+--------+----------------------------------------------------+
| 0x68 | xH | MULHIS | High 64 bits of signed product |
+------+---------+--------+----------------------------------------------------+
| 0x69 | xa | ABS | Absolute value (wrap on min-int) |
+------+---------+--------+----------------------------------------------------+
| 0x6A | xm | MIN | Minimum of b and a |
+------+---------+--------+----------------------------------------------------+
| 0x6B | xM | MAX | Maximum of b and a |
+------+---------+--------+----------------------------------------------------+
| 0x6C | xc | CLAMP | x lo hi -> clamp(x,lo,hi) |
+------+---------+--------+----------------------------------------------------+
| 0x6D | xf | FMA | a b c -> (a*b + c) with fixed scaling |
+------+---------+--------+----------------------------------------------------+
| 0x6E | x= | CMP | b a -> -1, 0, or 1 |
+------+---------+--------+----------------------------------------------------+
| 0x6F | x? | SGN | Sign: -1, 0, or 1 |
+------+---------+--------+----------------------------------------------------+
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-----------------------------------------------------
0x7_ - Extended Bitwise and Packing Operators (via x)
-----------------------------------------------------
+------+---------+---------+---------------------------------------------------+
| ID | x+Glyph | Name | Description |
+======+=========+=========+===================================================+
| 0x70 | x& | BAND | Bitwise AND |
+------+---------+---------+---------------------------------------------------+
| 0x71 | x| | BOR | Bitwise OR |
+------+---------+---------+---------------------------------------------------+
| 0x72 | x^ | BXOR | Bitwise XOR |
+------+---------+---------+---------------------------------------------------+
| 0x73 | x! | BNOT | Bitwise NOT |
+------+---------+---------+---------------------------------------------------+
| 0x74 | x< | SHL | Logical left shift |
+------+---------+---------+---------------------------------------------------+
| 0x75 | x> | SAR | Arithmetic right shift |
+------+---------+---------+---------------------------------------------------+
| 0x76 | x. | SHR | Logical right shift |
+------+---------+---------+---------------------------------------------------+
| 0x77 | x( | ROL | Rotate left |
+------+---------+---------+---------------------------------------------------+
| 0x78 | x) | ROR | Rotate right |
+------+---------+---------+---------------------------------------------------+
| 0x79 | x# | CLZ | Count leading zeros |
+------+---------+---------+---------------------------------------------------+
| 0x7A | x; | CTZ | Count trailing zeros |
+------+---------+---------+---------------------------------------------------+
| 0x7B | x@ | POPCNT | Population count |
+------+---------+---------+---------------------------------------------------+
| 0x7C | x[ | BEXTR | Bit extract: value lo len |
+------+---------+---------+---------------------------------------------------+
| 0x7D | x] | BINS | Bit insert |
+------+---------+---------+---------------------------------------------------+
| 0x7E | x, | PACK2 | Pack two 32-bit values into one 64-bit |
+------+---------+---------+---------------------------------------------------+
| 0x7F | x: | UNPACK2 | Unpack 64-bit into two 32-bit values |
+------+---------+---------+---------------------------------------------------+
k = (count & 63) for all 64-bit shifts/rotates.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-----------------------------------------
0x8_ - Extended Vector Primitives (via x)
-----------------------------------------
Vector values are represented as triples on the data stack: x y z with z on top.
All vector operations are componentwise over the current numeric model. Fixed-
point scaling follows the rules of 0x6_ (FMUL, FDIV, FMA).
+------+---------+--------+----------------------------------------------------+
| ID | x+Glyph | Name | Description |
+======+=========+========+====================================================+
| 0x80 | xv | VADD | (x1 y1 z1 x2 y2 z2 -> x y z) componentwise add |
+------+---------+--------+----------------------------------------------------+
| 0x81 | xV | VSUB | (x1 y1 z1 x2 y2 z2 -> x y z) componentwise |
| | | | subtract |
+------+---------+--------+----------------------------------------------------+
| 0x82 | xk | VSCALE | (x y z s -> x' y' z') scale by scalar s (uses FMUL |
| | | | if fixed-point) |
+------+---------+--------+----------------------------------------------------+
| 0x83 | xK | VSDIV | (x y z s -> x' y' z') divide by scalar s (0 vector |
| | | | if s==0) |
+------+---------+--------+----------------------------------------------------+
| 0x84 | xD | VDOT | (x1 y1 z1 x2 y2 z2 -> q) dot product |
+------+---------+--------+----------------------------------------------------+
| 0x85 | xx | VCROSS | (x1 y1 z1 x2 y2 z2 -> x y z) cross product |
+------+---------+--------+----------------------------------------------------+
| 0x86 | x2 | VNORM2 | (x y z -> q) squared norm (dot(v,v)) |
+------+---------+--------+----------------------------------------------------+
| 0x87 | xC | VCLAMP | (x y z lo hi -> x' y' z') clamp each component |
+------+---------+--------+----------------------------------------------------+
Remember: xx is legal because the first x is the one-shot extension modifier,
while the second x is simply the glyph being decoded in the extended table (here
mapped to VCROSS).
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-----------------------------------------------------
0x9_ - Extended Angle and Rotation Primitives (via x)
-----------------------------------------------------
This category reflects a later evolutionary stage ("1985-era" capability):
compact attitude and angle support built on top of the Apollo-like numeric core.
Angles are represented using the Numeric Model: fixed-point turns in Q32.32,
where 1.0 represents one full revolution.
+------+---------+---------+---------------------------------------------------+
| ID | x+Glyph | Name | Description |
+======+=========+=========+===================================================+
| 0x90 | xA | ATAN2 | (y x -> ang) compute angle from Cartesian |
| | | | components |
+------+---------+---------+---------------------------------------------------+
| 0x91 | xT | ANGNORM | (ang -> ang) normalize angle to canonical range |
+------+---------+---------+---------------------------------------------------+
| 0x92 | xP | SINCOS | (ang -> sin cos) compute sine and cosine together |
+------+---------+---------+---------------------------------------------------+
| 0x93 | xr | ROT2 | (y x ang -> y' x') 2D rotation |
+------+---------+---------+---------------------------------------------------+
| 0x94 | xR | ROTAX | (x y z ax ay az ang -> x' y' z') rotate vector |
| | | | around axis by angle |
+------+---------+---------+---------------------------------------------------+
Higher-level constructs (quaternions, matrices, frame transforms) are expected
to be implemented as library code in the grid.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
---------------------------------------------------------
0xA_ - Extended Orbital and Integrator Primitives (via x)
---------------------------------------------------------
This category reduces boilerplate and improve numerical stability. It
standardizes state propagation without embedding high-level astrodynamics
algorithms. Fungus Astronauticus becomes a flight computer.
Canonical state representation (STATE6):
px py pz vx vy vz with vz on top.
Canonical acceleration (ACC3):
ax ay az with az on top.
dt and mu are scalars in the same numeric model as all other values (Q32.32
fixed-point).
+------+---------+--------------+----------------------------------------------+
| ID | x+Glyph | Name | Description |
+======+=========+==============+==============================================+
| 0xA0 | xg | GRAV_CENTRAL | (px py pz mu -> ax ay az) central-body |
| | | | gravity |
+------+---------+--------------+----------------------------------------------+
| 0xA1 | xS | STEP_SI | (STATE6 ACC3 dt -> STATE6) semi-implicit |
| | | | Euler step |
+------+---------+--------------+----------------------------------------------+
| 0xA2 | xE | ENERGY_CHECK | (STATE6 mu -> e) compute orbital energy |
| | | | invariant |
+------+---------+--------------+----------------------------------------------+
| 0xA3 | xI | STEP_RK2 | (STATE6 ACC3 dt -> STATE6) midpoint |
| | | | integrator |
+------+---------+--------------+----------------------------------------------+
| 0xA4 | x4 | STEP_RK4 | (STATE6 ACC3 dt -> STATE6) classical RK4 |
| | | | step |
+------+---------+--------------+----------------------------------------------+
Higher-level constructs (Kepler solvers, Lambert problems, orbital elements)
remain library code in the grid.
--------------------------------------------------------------------------------
===========
DETERMINISM
===========
The language is deterministic.
--------------------------------------------------------------------------------
======
DESIGN
======
Fungus Astronauticus intentionally avoids dynamic dictionaries, garbage
collection, or hidden execution environments. Definitions exist physically in
the grid. An instruction pointer carries only its stacks and direction.
--------------------------------------------------------------------------------
Leave a comment