Modules & Exports

Design once, use the same model

A pickup module contains physical construction, equivalent circuit parameters, metadata, simulated-string-motion input, and raw-DI output. An effect module contains its circuit or hybrid design. A cabinet module contains driver, enclosure, microphone, and IR assets.

Modules can be composed into guitars, pedalboards, rigs, and full programs. The standalone designer and plugin wrappers should host the same processing behavior rather than translating designs into unrelated presets.

Explicit boundaries

Pickup modules do not contain guitar placement
Guitar modules own scale, strings, pickup placement, switching, and routing
Pedal modules remain reusable outside one pedalboard
Enclosures bind visible controls to exported parameters
Cabinet modules can export native data and standard impulse responses
Rig modules compose guitar, pickups, pedals, amp, speaker, and microphone
Program modules can expose the complete performance engine as an instrument plugin

A manifest explains the artifact

ArcoBASIC expresses module identity, engine type, input and output meaning, units, and export targets as ordinary readable data. A host does not need to guess what “audio in” means for a physical pickup.

ArcoBASICArcoBASIC communication example: define a pickup module boundary

' Describe an artifact so editors and hosts agree on its meaning.
pickup = {
    "Schema": "com.arcoaura.module.v1",
    "Id": "pickup.alnico5.single",
    "Kind": "PICKUP",
    "Engine": "PHYSICAL CIRCUIT",
    "Inputs": [{"Id": "string_motion", "Channels": 1}],
    "Outputs": [{"Id": "raw_pickup_di", "Channels": 1}],
    "Exports": ["ARCOAURA MODULE"]
}

PRINT pickup.Id
inputs = pickup.Inputs
outputs = pickup.Outputs
firstInput = inputs[0]
firstOutput = outputs[0]
PRINT firstInput.Id
PRINT firstOutput.Id

Export preserves causality

The artifact should preserve the model used to audition it. A pickup export should not become a static equalizer curve that forgets construction and load. A speaker IR should be reproducible from its physical design. A plugin should wrap the same engine the editor runs.

Stable serializers remain application-level work. The library already defines module manifests and specific structures so file formats can evolve deliberately.

What a manifest is actually for

The specific schema fields, Id, Kind, Engine, Inputs, Outputs, are particular to how ArcoAura describes a pickup or cabinet module. A different system will need entirely different fields. What generalizes is treating the manifest as a contract, not paperwork.

The same reasoning sits behind any well-designed interface contract: an API schema that states what a field means and what it explicitly excludes, a data export format that preserves provenance instead of flattening it into a snapshot, a plugin architecture that refuses to let the exported version drift from the version actually being edited.

Write down what a boundary explicitly does not contain, not only what it contains. "Pickup modules do not contain guitar placement" is a rule a reader can check code against, unlike an implicit convention nobody wrote down.
Let a manifest declare meaning, not just shape. Naming an input "string_motion" and an output "raw_pickup_di" tells a host what the numbers mean, so nobody has to guess what "audio in" refers to for a physical pickup versus an effect.
Require export to preserve the reason a thing sounds the way it does. Refusing to let a pickup export collapse into a static equalizer curve keeps the artifact traceable back to its construction and load instead of a black box matching one recorded moment.
Make every host, editor, standalone app, plugin, run off the same manifest and the same engine, so "exported" never quietly comes to mean a second implementation that will eventually disagree with the first.

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.

Manifest: Structured metadata describing what a program contains, needs, exposes, and is allowed to do.
Signal chain: The ordered path a signal follows through a system. In ArcoAura it begins with string motion and can continue through pickup, pedals, amplifier, speaker, microphone, and room.
Impulse response: A recording or generated description of how a system responds to a very short impulse. Convolution can apply that response to other audio.