ArcoFission

One authoritative interpretation

ArcoFission follows a single pipeline: source becomes tokens, a canonical AST, semantically validated intent in A-MIR, optimized representation, and finally target output. Later stages do not reinterpret raw source.

That rule prevents a dangerous compiler failure mode in which syntax appears to parse successfully but silently disappears before executable output. Every supported construct must survive every applicable stage or produce a deterministic diagnostic.

Inspectable stages

AST reveals program structure
A-MIR reveals typed, architecture-independent intent
Bytecode reveals the hosted VM representation
Calling-convention output exposes ABI decisions
x86-64 reveal exposes native lowering
PE32+ output boots as a self-contained UEFI application

The same source reaches hardware

A freestanding profile rejects hosted conveniences and makes the target contract explicit. This actual control-flow fixture is compiled through A-MIR and x86-64 lowering rather than translated through C or handwritten assembly.

ArcoBASICArcoFission fixture: freestanding control flow

' Tell ArcoFission exactly where this program will run.
#PROFILE UEFI
#TARGET X86_64
#RUNTIME NONE
#CALLCONV UEFI
#EXPORT "efi_main"

FUNCTION Main(imageHandle AS UEFI.Handle, systemTable AS UEFI.SystemTable) AS U64
    ' Ordinary structured code survives the trip to bare hardware.
    LET count AS U8 = 0
    WHILE count < 3
        IF count = 1 THEN
            systemTable.ConsoleOut.Write("middle\r\n")
        END IF
        count = count + 1
    WEND
    systemTable.ConsoleOut.Write("done\r\n")
    RETURN count
END FUNCTION

The bug class one pipeline rule out

A compiler that lets a later stage silently reinterpret raw source instead of consuming the previous stage's validated output can let a construct look like it compiled while it quietly vanished before the executable. Naming that failure mode directly, and building a rule against it, is the useful idea here, independent of compilers entirely.

Find the specific way your own pipeline could go silent instead of loud. For a compiler it is source getting reinterpreted past validation; for a data pipeline it might be a null silently dropped instead of rejected; the shape of the failure matters more than the domain.
Make every stage boundary a hard contract: what survives to the next stage must have already been validated, not merely produced. A-MIR only accepts what has already been checked; it never re-derives meaning from the original text.
Turn every unsupported case into a deterministic diagnostic instead of a silent no-op. A construct that cannot be lowered should fail loudly at the stage that discovers it, not disappear and leave a working-looking build.

LEARNING LAYER

Key terms, in plain language

You do not need a systems background to follow the work. These are the specialized terms used on this page.

ASTAbstract Syntax Tree: A tree-shaped representation of source code after parsing. It preserves program structure while leaving behind formatting details such as whitespace.
A-MIRArco Mid-Level Intermediate Representation: ArcoFission’s typed, architecture-independent description of what a program means. Later compiler stages lower this intent into bytecode or native machine code.
Bytecode: A compact instruction format for a virtual machine. It is lower-level than source code but remains portable across physical processor types.
VMVirtual Machine: A software execution engine that reads bytecode instructions. Here, VM means a language runtime, not necessarily a simulated whole computer.
ABIApplication Binary Interface: The low-level agreement that lets separately compiled code call each other. It defines details such as argument locations, return values, register use, and stack layout.
Native lowering: The compiler step that converts architecture-independent program intent into instructions for a real processor, such as x86-64.
PE32+Portable Executable 32-bit Plus: A 64-bit executable file format used by UEFI and Windows. ArcoFission can place freestanding ArcoBASIC machine code into a PE32+ image that firmware can boot.
UEFIUnified Extensible Firmware Interface: The standardized firmware environment that starts a modern computer before an operating system takes control. Arcology OS currently enters through UEFI during hardware bring-up.