Build it. Break it. Understand it. Build it better.
I'm Soala Amachree, a Mechatronics Engineering student interested in the intersection of software, computer systems, electronics, intelligence and machines.
I don't want to only use technology.
I want to understand what happens underneath it — from software and circuits to processors, memory, operating systems, robots and intelligent machines.
My goal is to become an engineer capable of moving across the stack:
Software → Systems → Electronics → Embedded → AI → Robotics → Machines
HUMAN IDEA
│
▼
┌────────────────┐
│ SOFTWARE │
│ AI / APPS │
└───────┬────────┘
│
▼
┌────────────────┐
│ SYSTEMS │
│ OS / RUNTIME │
└───────┬────────┘
│
▼
┌────────────────┐
│ COMPUTER ARCH │
│ CPU / MEMORY │
└───────┬────────┘
│
▼
┌────────────────┐
│ EMBEDDED │
│ ELECTRONICS │
└───────┬────────┘
│
▼
┌────────────────┐
│ ROBOTICS │
│ MACHINES │
└────────────────┘
I like understanding systems from the inside out.
Gorgon is a long-term systems engineering project consisting of three separate repositories and three distinct systems.
They share a common vision, but Phase 1 is not upgraded into Phase 2, and Phase 2 is not upgraded into Phase 3.
Each phase answers a different engineering question:
PHASE 1
"Can I design and simulate the operating-system experience?"
│
▼
PHASE 2
"Can I actually build an operating system?"
│
▼
PHASE 3
"Can I create a practical Linux distribution around
the ideas, tools and experience I've developed?"
The overall direction is:
Simulation → Operating System → Linux Distribution
Separate repository · Python · Pygame · Completed
Phase 1 is a virtual operating-system simulator.
Its purpose was to explore the desktop experience, application architecture, filesystem concepts and system interaction without implementing a real kernel.
┌────────────────────────────────────┐
│ VIRTUAL DESKTOP │
├────────────────────────────────────┤
│ │
│ Window Management │
│ File Explorer │
│ Terminal / Shell │
│ Text Editor │
│ Application System │
│ Virtual Filesystem │
│ Persistent Storage │
│ System Services │
│ │
└────────────────────────────────────┘
Explore the user experience before attempting the operating-system engineering underneath it.
Phase 1 now serves as a UX reference and experimental environment for ideas that may influence the later systems.
Separate repository · C · C++ · Assembly · x86-64 · Real OS Development
Phase 2 is a completely separate project.
This is where Gorgon becomes an actual bootable operating system with its own kernel, boot process, userspace, drivers and system architecture.
It is not the Python simulator rewritten in another language.
HOST COMPUTER
│
▼
┌──────────────────────┐
│ GORGON LAUNCHER │
│ C++ │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ QEMU + KVM │
│ │
│ Virtual CPU │
│ Virtual RAM │
│ Virtual Disk │
│ VirtIO Network │
│ VirtIO GPU │
│ Virtual Devices │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ GORGON BOOTLOADER │
└──────────┬───────────┘
│
▼
┌─────────────────────────────┐
│ GORGON KERNEL │
├─────────────────────────────┤
│ CPU / Architecture │
│ Memory Management │
│ Virtual Memory / Page Tables│
│ Processes / Threads │
│ Preemptive Scheduler │
│ Interrupts │
│ Drivers / HAL │
│ VFS / Filesystems │
│ Networking │
│ IPC │
│ System Calls │
│ Security / Isolation │
└──────────────┬──────────────┘
│
▼
┌─────────────────────────────┐
│ GORGON INIT │
└──────────────┬──────────────┘
│
▼
┌────────────────────────────────────┐
│ USERSPACE │
├────────────────────────────────────┤
│ Desktop │
│ Window System / Compositor │
│ Applications │
│ System Services │
│ Gorgon libc │
│ POSIX-oriented Environment │
│ Runtimes │
│ Sandboxes / Containers │
│ Linux ABI Compatibility │
└────────────────────────────────────┘
GORGON NATIVE PROGRAM
│
▼
GORGON ABI / API
│
▼
GORGON KERNEL
POSIX SOFTWARE
│
▼
GORGON LIBC
│
▼
GORGON SYSCALLS
│
▼
GORGON KERNEL
LINUX SOFTWARE
│
▼
LINUX ABI COMPATIBILITY
│
▼
GORGON KERNEL
POSIX compatibility does not make Gorgon Linux.
Linux compatibility is therefore treated as a separate compatibility layer.
┌─────────────────────────────────────┐
│ STAGE 1 — CORE KERNEL │
│ │
│ Bootloader │
│ x86-64 │
│ Memory │
│ Interrupts │
│ Processes │
│ Scheduler │
│ Drivers │
└──────────────────┬──────────────────┘
│
▼
┌─────────────────────────────────────┐
│ STAGE 2 — USERSPACE FOUNDATION │
│ │
│ Syscalls │
│ IPC │
│ VFS │
│ Filesystem │
│ Gorgon libc │
│ Static ELF │
│ Init │
│ Shell / Utilities │
│ POSIX-oriented APIs │
└──────────────────┬──────────────────┘
│
▼
┌─────────────────────────────────────┐
│ STAGE 3 — GRAPHICS & DESKTOP │
│ │
│ VirtIO-GPU │
│ Framebuffers / Surfaces │
│ Window System │
│ Compositor │
│ UI Framework │
│ Asset Manager │
│ Settings Service │
│ Desktop │
│ File Explorer │
│ Terminal │
└──────────────────┬──────────────────┘
│
▼
┌─────────────────────────────────────┐
│ STAGE 4 — ECOSYSTEM & COMPATIBILITY│
│ │
│ Networking │
│ Audio │
│ Sandboxing / Containers │
│ Python Runtime │
│ Lightweight Web Engine │
│ Media / FFmpeg │
│ Linux ABI Compatibility │
│ Dynamic Linking │
│ Chromium │
│ Real Hardware │
└─────────────────────────────────────┘
The real Gorgon OS is intended to have a custom desktop, graphics stack and visual identity.
/system/
├── assets/
│ ├── icons/
│ ├── wallpapers/
│ ├── fonts/
│ ├── ui/
│ └── themes/
│
└── ...
The system asset layer will support:
- Custom icons
- Wallpapers
- UI graphics
- Transparent PNG assets
- High-resolution images
- Dynamic fonts
- Themes
- Rounded UI elements
- Alpha blending
The Gorgon UI library is planned to use technologies such as:
stb_image · stb_truetype · FreeType
where appropriate.
System configuration should not be hardcoded into individual applications.
Gorgon will use a centralized settings architecture:
SETTINGS APP
│
▼
┌─────────────────┐
│ SETTINGS SERVICE│
└────────┬────────┘
│
IPC
│
┌────────────┴────────────┐
▼ ▼
DESKTOP SERVICE COMPOSITOR
│ │
└────────────┬────────────┘
▼
LIVE UI UPDATE
Possible configuration includes:
- Wallpaper
- Accent colors
- Themes
- Icon sets
- Window opacity
- UI preferences
- Desktop behavior
- User preferences
Changes should be applied live without restarting the desktop whenever practical.
APPLICATION
│
▼
GORGON GUI / GRAPHICS API
│
▼
WINDOW SURFACE
│
▼
COMPOSITOR
│
├── Damage Tracking
├── Alpha Blending
├── Windows
└── Desktop
│
▼
RENDERER
│
▼
VIRTIO-GPU / PHYSICAL GPU
Applications should interact with managed window surfaces rather than directly manipulating raw framebuffer memory.
SDL2 may eventually be ported as a userspace library/compatibility layer, but it is not the foundation of Gorgon's graphics architecture.
Application
│
▼
Gorgon libc / API
│
▼
System Calls
│
▼
VFS
│
├── Gorgon Filesystem
├── Device Files
└── Future Filesystem Drivers
│
▼
Storage Driver
│
▼
VirtIO / NVMe / AHCI
Early userspace programs will prioritize static ELF executables.
Dynamic linking and shared libraries come later once the fundamental execution environment is stable.
Gorgon will eventually include a lightweight isolation system inspired by concepts such as:
- FreeBSD Jails
chroot- Process isolation
- Filesystem isolation
- Resource limits
- Permission boundaries
- IPC/network restrictions
The goal is a genuine Gorgon sandbox/container subsystem, not simply a chroot wrapper.
GORGON KERNEL
│
├───────────────┐
│ │
▼ ▼
NORMAL APP SANDBOX
│
┌─────┴─────┐
│ │
Filesystem Process
Isolation Isolation
Containers share the Gorgon kernel.
Virtual machines have their own kernels.
The long-term userspace environment is intended to support:
GORGON
│
┌───────────┼───────────┐
▼ ▼ ▼
Native Apps Runtimes Services
│
┌────────┼────────┐
▼ ▼ ▼
Python Web Media
Engine
│
▼
Chromium
The order matters:
Networking → Graphics → Window System → Runtime → Dynamic Linking → Linux Compatibility → Chromium
Chromium is intended to become a major real-world validation target for the operating system.
QEMU/KVM is the development and virtualization environment, not Gorgon's hardware dependency.
The architecture is intended to eventually support real x86-64 machines.
GORGON
│
HARDWARE ABSTRACTION
│
┌─────────┼───────────┐
▼ ▼ ▼
QEMU LAPTOP DESKTOP
VirtIO Drivers Drivers
│ │ │
└─────────┼───────────┘
▼
HARDWARE
The driver architecture will eventually cover areas such as:
- VirtIO
- PCI
- ACPI
- AHCI / SATA
- NVMe
- xHCI / USB
- UEFI GOP / framebuffer
- Networking
- Audio
- Physical GPUs
UEFI is the primary modern physical boot target, with legacy BIOS/CSM potentially supported as an additional path.
The long-term goal is to boot Gorgon from USB and physical storage, not only inside QEMU.
Separate repository · Linux kernel · Linux distribution
Phase 3 is another completely separate project.
It is not the continuation of the Phase 2 kernel.
Instead, Phase 3 asks a different question:
Can I build a practical Linux distribution around the ideas, tools, UX and engineering experience developed through the earlier projects?
┌─────────────────────────────────────────┐
│ GORGON LINUX │
├─────────────────────────────────────────┤
│ │
│ LINUX KERNEL │
│ │ │
│ ┌────────┴────────┐ │
│ ▼ ▼ │
│ GENERAL PURPOSE SECURITY │
│ ECOSYSTEM TOOLING │
│ │ │ │
│ Ubuntu / Debian Kali ecosystem │
│ │ │ │
│ └────────┬────────┘ │
│ ▼ │
│ GORGON EXPERIENCE │
│ │
│ Desktop / UX │
│ Custom Services │
│ Developer Tooling │
│ AI / ML Tooling │
│ Robotics Tooling │
│ Security Tooling │
│ Automation │
│ │
└─────────────────────────────────────────┘
The exact implementation and package architecture will evolve as the project develops.
The important distinction is:
PHASE 1
Python / Pygame
VirtualOS Simulator
│
│ separate project
▼
PHASE 2
C / C++ / Assembly
Gorgon Kernel
Real Operating System
│
│ separate project
▼
PHASE 3
Linux Kernel
Gorgon Linux
Practical Linux Distribution
| Phase | System | Core Technology | Purpose |
|---|---|---|---|
| Phase 1 | Gorgon VirtualOS | Python / Pygame | Simulate and explore OS UX |
| Phase 2 | Gorgon OS | C / C++ / Assembly | Build a real operating system |
| Phase 3 | Gorgon Linux | Linux Kernel | Build a practical Linux distribution |
They are connected by a long-term engineering vision, not by being successive versions of the same codebase.
C · C++ · Assembly · Linux · GCC · GDB · QEMU · KVM · Docker · CMake · SDL2
Kernel Development · x86-64 · ELF · Bootloaders · Memory Management · Virtual Memory · Interrupts · Processes · Scheduling · VFS · Drivers · System Calls · IPC
Python · PyTorch · TensorFlow · OpenCV · Machine Learning · Computer Vision · Reinforcement Learning
Arduino · Embedded Systems · Electronics · KiCad · CAD · Fusion 360 · Automation · Robotics
Git · GitHub · VS Code · React · Tailwind · Flask · Django
┌────────────────────────────────────────────┐
│ CURRENT LEARNING QUEUE │
├────────────────────────────────────────────┤
│ │
│ > Advanced C │
│ > C++ │
│ > Assembly │
│ > Computer Architecture │
│ > Operating System Development │
│ > Linux System Programming │
│ > QEMU / KVM Virtualization │
│ > ELF & Toolchains │
│ > Memory Management │
│ > Embedded Systems │
│ > Robotics │
│ > Artificial Intelligence │
│ > Computer Vision │
│ > Reinforcement Learning │
│ > Rust │
│ > ROS 2 │
│ > Embedded Linux │
│ > Containers & Sandboxing │
│ │
└────────────────────────────────────────────┘
| Project | Description |
|---|---|
| 🖥️ Gorgon VirtualOS | Python/Pygame operating-system simulator exploring desktop UX, virtual filesystems, applications and system interaction |
| ⚙️ Gorgon OS | Separate real operating-system project focused on bootloaders, kernel development, x86-64, drivers, userspace and hardware |
| 🐧 Gorgon Linux | Separate Linux distribution project combining general-purpose Linux, security tooling and the Gorgon ecosystem |
| 🌌 Project Hollow | Long-term exploration of intelligent, secure and developer-focused computing environments |
| 🐍 AI Snake | Reinforcement-learning Snake agent using Deep Q-Learning |
| ♟️ Python Chess | Chess application exploring game logic and AI |
| 🎓 School Management System | Student records, grading and academic management |
| 🤖 AI Projects | Machine learning, computer vision and intelligent-system experiments |
| 🔧 Electronics Projects | Embedded systems and hardware experimentation |
2024
│
├── Python
├── Programming Fundamentals
└── First Software Projects
│
▼
2025
│
├── Applications & Games
├── AI & Computer Vision
├── Electronics
└── Engineering Projects
│
▼
2026
│
├── Mechatronics Engineering
├── C / C++
├── Assembly
├── Linux
├── Computer Architecture
├── Virtualization
├── QEMU / KVM
├── Operating Systems
├── Gorgon
├── AI
└── Robotics
│
▼
FUTURE
│
├── Advanced OS Development
├── Gorgon Linux
├── Robotics
├── AI
├── Embedded Systems
├── Intelligent Machines
└── Engineering Startups
I like learning technology from the inside out.
APPLICATION
▲さんかく
│
RUNTIME
▲さんかく
│
OPERATING
SYSTEM
▲さんかく
│
KERNEL
▲さんかく
│
COMPUTER ARCH.
▲さんかく
│
HARDWARE
▲さんかく
│
PHYSICAL WORLD
The deeper I go, the more interesting it becomes.
I don't want to memorize how systems work.
I want to build enough of them to understand why they work.
I don't want to be restricted to only software or only hardware.
I want to become an engineer who can move between:
Code → Systems → Electronics → Embedded → AI → Robotics → Machines
and understand how those layers interact.
Eventually, I want to build systems where those disciplines aren't separate projects.
They're one integrated system.