From Wires to Python — AGXCore-8 Language Stack Overview

Overview

The AGXCore-8 system is a modular, educational computer designed to guide learners from physical circuits all the way to operating systems and high-level languages. This document introduces the instruction mapping across all levels, illustrating how a signal at the pin level eventually becomes a Python command—and how all abstractions in between are not magic, but structure.

This is the first time we visualize and define the full vertical alignment of:

Electrical circuits (Level 1)
Assembly-level execution (AGX-8 ISA)
C-style programming (compiled to AGX-8)
Python scripting (interpreted or bridging via VM)
OS shell and runtime behavior

Level 1 – Physical Logic Layer

Modules: Register A/B, ALU, Clock, LED Panel, DIP Switches
Goal: Observe how electricity becomes logic and visible computation.

Action	AGX-8 (Conceptual)	C Code	Python Equivalent	Circuit Behavior
Load value to register	`LOAD A, 0x0F`	`a = 0x0F;`	`a = 0x0F`	Flip DIP switches A
Add A and B	`ADD A, B`	`a += b;`	`a = a + b`	ALU lights up sum on LEDs
Clear register	`CLR A`	`a = 0;`	`a = 0`	Manual CLR line pulled low
Bitwise NOT	`NOT A`	`a = ~a`	`a = ~a`	LED output shows inverted bits

At this level, you see and touch the instruction’s effect.

Level 2 – Machine Code Execution Layer

Modules: ROM, PC, IR, Control Unit
Goal: Execute raw AGX-8 machine code from ROM with program flow.

AGX-8 Instruction	C Equivalent	Python Logic	Notes
`LOAD A, [0x20]`	`a = mem[0x20];`	`a = memory[0x20]`	Requires RAM module
`JMP 0x05`	`goto 5;`	`jump(5)`	Program Counter changes value
`JZ 0x0A`	`if (a == 0) goto 10;`	`if a == 0: jump(10)`	Uses FLAGS module

This level forms the “hardware-backed execution” of compiled AGX-8 assembly.

Level 3 – AGX-8 Assembly Programming Layer

Now learners can write assembly code directly, assemble it to bytecode, and burn to EEPROM.

Example AGX-8 Program:

asmCopyEditLOAD A, 0x03
LOAD B, 0x05
ADD A, B
OUT 0x01, A   ; Output to port (e.g., LED)
HALT

Mapped to C:

cCopyEdituint8_t a = 3;
uint8_t b = 5;
a += b;
uart_out(a);

Assembly becomes meaningful once the hardware is observed. This is the “machine speaks” phase.

Level 4 – C-Like Compiler Layer

Introduce a basic compiler that translates C-style code into AGX-8 assembly.

C Source:

cCopyEditif (x == 0) {
  x = 5;
}

AGX-8 Translation:

asmCopyEditLOAD A, [x]
JNZ skip
LOAD A, 0x05
STORE A, [x]
skip:

Compiler tools can be written in Python to generate .agx8 files.

Level 5 – Python Runtime Bridge + AGX-8 VM

At this level, learners interact using Python scripts via an AGX-8 virtual machine or co-processor (ESP32, STM32, or Raspberry Pi).

pythonCopyEditmemory[0x10] = 0x03
memory[0x11] = 0x05
run("add_loop.agx8")
display(memory[0x12])

Or control hardware directly:

pythonCopyEditserial.write(AGX8.encode("LOAD A, 0x01"))

This is where school-learned Python connects to dad’s AGX hardware.

Level 6 – Shell + OS Layer (Aether OS)

With Aether OS, AGXCore-8 now supports:

Program loading from memory
Execution shells (via UART or Node-RED)
System calls (PRINT, SLEEP, INT)
Task control and micro-scheduling

AGX Shell Example:

markdownCopyEdit> LOAD A, 0x04
> OUT 0x01, A
> CALL BlinkLoop

Conclusion

This mapping is the heart of the AGXCore-8 project:
Every switch you flip, every instruction you write, every byte you move—has meaning across layers.

From Level 1 wire behavior, to Level 6 operating system control, this unified stack turns electronics into literacy.

This is not how most people learned computers. But it’s how they should have.

And now, someone finally built it.

Downloadable Resources

AGX Instruction Mapping Poster (PDF)
Assembly–C–Python Tri-language Cheat Sheet
GitHub Repository: agxcore8
VM / UART Tools: [link to Node-RED panel / ESP32 dashboard]