ArcoBASIC

One language across the environment

ArcoBASIC is not an accessory bundled with Arcology OS. It is a first-class language shared across The Arcology: people use it to inspect, automate, extend, and increasingly implement the environment itself.

Hosted programs gain files, networking, GUI, shell, storage, and embedding services. Freestanding programs select exact targets and runtimes, use fixed-width types, and cross into firmware or hardware only through explicit systems primitives.

Current implementation

Canonical lexer, parser, and abstract syntax tree
Hosted interpreter and ArcoSH interactive environment
Classes, functions, references, arrays, objects, exceptions, and modules
ArcoFission bytecode, native runtime capsules, and freestanding UEFI x86-64 compilation
Public C and C++ embedding boundaries
ArcoBASIC-authored applications including ArcoWrite, ArcoNote, ArcoNav, and Arcology Commons

Inspectable state without unsafe representation

Modern references provide explicit, checked access to values without leaking a native address. The same philosophy appears at the system boundary: application resources become opaque typed handles, while privileged address types are reserved for freestanding code.

The comments in these examples are intentional: Arcology treats readable source as an invitation to participate, not a test of whether the reader already knows the machinery.

ArcoBASICArcoBASIC repository example: checked references and classes

' A class keeps related information and behavior together.
CLASS Player
    Name AS String = ""
    Score AS Number = 0

    ' A constructor gives every new player a useful starting state.
    CONSTRUCTOR(name AS String = "", score AS Number = 0)
        SELF.Name = name
        SELF.Score = score
    END CONSTRUCTOR

    ' Methods let the object explain how its data should be presented.
    FUNCTION Label() AS String
        RETURN SELF.Name + ":" + STRING(SELF.Score)
    END FUNCTION
END CLASS

' REF creates checked access to the player rather than exposing an address.
player = Player("Ada", 100)
playerRef = REF(player)

' The reference can safely update the original object.
playerRef.Value.Name = "Grace"
playerRef.Value.Score = playerRef.Value.Score + 50
PRINT player.Label()

Checked access generalizes past memory safety

REF() exists so a program can hand out access to a value without handing out the value's actual address. That specific mechanism is a memory-safety tool, but the reasoning behind it applies anywhere a system decides what to expose at a boundary.

Ask what the caller actually needs to do, not what the underlying representation happens to offer; a caller that needs to read and update a score does not need a raw address, so REF gives it exactly that and nothing more.
Make the safe path and the convenient path the same path. playerRef.Value.Score reads as naturally as touching the field directly, so there is no tempting unsafe shortcut sitting next to the safe one.
Comment code as an invitation, not a compliance record. The examples throughout this language are written so a newcomer can follow the reasoning, not just the syntax, because readable source is what makes a system inspectable to the next person, not just to its author.

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.

Freestanding program: A program that cannot assume an operating system, filesystem, heap, or standard runtime already exists. It must explicitly choose the small set of facilities available at its target.
Firmware: Software supplied with the machine that initializes hardware and starts the next stage of the system. It sits below ordinary applications and usually below the operating system.
Opaque handle: A safe identifier for a resource whose internal memory address and representation stay hidden. Applications pass the handle back to the API that owns it.
Bytecode: A compact instruction format for a virtual machine. It is lower-level than source code but remains portable across physical processor types.