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]