Skip to content
BranchesTags

Repository files navigation

HoloKernel QEMU Emulator

A next-generation operating system kernel featuring holographic memory management and advanced entity-based architecture.

🚀 Overview

HoloKernel is an experimental kernel that implements innovative holographic memory management concepts, providing a unique approach to system resource allocation and entity management. The kernel is designed with modularity and extensibility in mind, featuring a clean separation between different system entities.

✨ Key Features

  • Holographic Memory Management: Advanced memory allocation using holographic dimensions (512x512 matrix)
  • Entity-Based Architecture: Modular design with CPU, Memory, Device, and Filesystem entities
  • Cross-Platform Build System: Automated compilation with GitHub Actions
  • Local Dependency Management: Self-contained build environment with no external downloads
  • 32-bit i686 Target: Optimized for x86 architecture
  • QEMU Testing Ready: Fully bootable kernel image for virtualization testing

🏗️ Architecture

Core Components

  • Boot Loader (boot.asm): Initial system bootstrap and kernel loading with protected mode transition
  • Kernel Entry (kernel_entry.asm): Assembly entry point and system initialization
  • Main Kernel (holographic_kernel.c): Core kernel implementation with holographic memory management
  • Linker Script (linker.ld): Memory layout and section organization

Entity System

The kernel implements four primary entity types:

  • ENTITY_CPU: Processor management and scheduling
  • ENTITY_MEMORY: Holographic memory allocation and management
  • ENTITY_DEVICE: Hardware device abstraction
  • ENTITY_FILESYSTEM: File system operations and storage

🛠️ Quick Installation Guide

Prerequisites

  • Ubuntu/Debian-based Linux system
  • Internet connection for package downloads
  • At least 1GB free disk space

One-Command Installation

# Update system and install all required packages
sudo apt update && sudo apt install -y gcc-multilib nasm qemu-system-x86 wget make

Step-by-Step Setup

# 1. Create project directory
mkdir holokernel_project && cd holokernel_project

# 2. Download the 5 core files
wget https://raw.githubusercontent.com/rainmanp7/holokernel/main/boot.asm
wget https://raw.githubusercontent.com/rainmanp7/holokernel/main/holographic_kernel.c
wget https://raw.githubusercontent.com/rainmanp7/holokernel/main/Makefile
wget https://raw.githubusercontent.com/rainmanp7/holokernel/main/linker.ld
wget https://raw.githubusercontent.com/rainmanp7/holokernel/main/kernel_entry.asm

# 3. Build the kernel
make clean && make all

# 4. Test with QEMU
timeout 30 qemu-system-x86_64 -drive format=raw,file=emergeos.img -m 256 -nographic -serial mon:stdio

Required Packages

  • gcc-multilib: Cross-platform C compiler with 32-bit support
  • nasm: Netwide Assembler for x86 assembly code
  • qemu-system-x86: x86 system emulator for kernel testing
  • make: Build automation tool
  • wget: File download utility

Note: No dedicated cross-compiler required - uses standard gcc with multilib support.

🧪 Testing & Verification

Success Indicators

  • Build completes without errors
  • emergeos.img file is created (bootable kernel image)
  • QEMU boots and shows kernel initialization messages
  • No kernel panic or hang during boot process

Troubleshooting

  • Build Issues: Ensure all 5 files downloaded correctly, verify gcc-multilib installation
  • Boot Issues: Increase QEMU memory (-m 512), use -serial mon:stdio for debugging
  • File Issues: Check that emergeos.img was created successfully

🏗️ Advanced Building

Prerequisites (Advanced)

The project includes a complete cross-compilation toolchain that builds automatically:

  • NASM (Netwide Assembler) for assembly code
  • Binutils (i686-elf) for linking and object manipulation
  • GCC (i686-elf) for C compilation

Local Build (Advanced)

# Clone the repository
git clone https://github.com/rainmanp7/holokernel.git
cd holokernel

# Build using the standard makefile
make

# Or use the modified makefile for native tools
make -f makefile.modified

Remote Build (GitHub Actions)

The project includes automated CI/CD with GitHub Actions:

  • Automatic cross-compiler toolchain setup
  • Kernel compilation and linking
  • Build artifact generation
  • Caching for improved build times

📁 Project Structure

holokernel/
├── boot.asm                 # Boot loader implementation
├── kernel_entry.asm         # Kernel entry point
├── holographic_kernel.c     # Main kernel code
├── linker.ld               # Linker script
├── Makefile                # Build configuration (lowercase)
├── .github/workflows/      # CI/CD automation
├── dependencies/           # Local toolchain and sources
│   ├── toolchain/         # Built cross-compiler tools
│   ├── sources/           # Source packages (binutils, gcc, nasm)
│   └── build/             # Build directories
└── cross-compiler/        # Legacy compiler cache

🔧 Memory Configuration

  • Holographic Dimensions: 512x512 matrix for advanced memory mapping
  • Base Memory Address: 0xA0000
  • Memory Size: 0x10000 (64KB holographic memory region)
  • Video Memory: 0xB8000 (VGA text mode)
  • Test Memory: 0x80000 (for memory validation)

🚦 Development Status

  • ✅ Core kernel structure implemented
  • ✅ Holographic memory management framework
  • ✅ Entity-based architecture design
  • ✅ Cross-compilation toolchain setup
  • ✅ Automated build system
  • ✅ QEMU bootable kernel image
  • ✅ Protected mode transition in bootloader
  • 🔄 Advanced memory allocation algorithms (in progress)
  • 🔄 Device driver framework (planned)
  • 🔄 Filesystem implementation (planned)

🌐 Integration with HyperdimensionalAI

This kernel serves as the foundation for advanced hyperdimensional computing systems. The HoloKernel integrates with cutting-edge research in quantum computing and dimensional entity management.

Related Project: HyperdimensionalAI

👥 Development Team

Current Development Team:

  • rainmanp7 - Lead Developer & Architect
  • nonbios-1.1 - AI Software Engineer & Co-Developer

Looking for Contributors! We welcome developers interested in:

  • Kernel development and low-level programming
  • Holographic memory management research
  • Hyperdimensional computing concepts
  • Quantum computing integration
  • Advanced operating system architecture

🤝 Contributing

Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests.

Development Guidelines

  1. Code Style: Follow the existing code style and architecture patterns
  2. Testing: Test builds locally before submitting PRs using both makefiles
  3. Documentation: Update documentation for new features and architectural changes
  4. Compatibility: Ensure compatibility with the i686-elf target architecture
  5. Commit Messages: Use clear, descriptive commit messages following conventional commits

Getting Started with Development

# Fork and clone your fork
git clone https://github.com/YOUR_USERNAME/holokernel.git
cd holokernel

# Create a feature branch
git checkout -b feature/your-feature-name

# Make your changes and test
make clean && make

# Commit and push
git add .
git commit -m "feat: add your feature description"
git push origin feature/your-feature-name

🐛 Troubleshooting

Common Build Issues

  • Cross-compiler not found: Ensure the toolchain is built using GitHub Actions or manually
  • Memory allocation errors: Check that target memory addresses don't conflict
  • Assembly linking issues: Verify NASM version compatibility and syntax

Getting Help

  • Open an issue for bugs or questions
  • Check existing issues for similar problems
  • Review the build logs in GitHub Actions for detailed error information

📄 License

This project is licensed under the terms specified in the LICENSE file.

🔬 Research & Innovation

HoloKernel represents cutting-edge research in:

  • Holographic memory management techniques
  • Entity-based operating system design
  • Advanced kernel architecture patterns
  • Cross-platform development methodologies
  • Hyperdimensional computing integration
  • Quantum computing interfaces

🌏 Origin & Historical Significance

Build Origin: Philippines, Mindanao, Davao Del Sur, Santa Cruz

Historical Achievement: The first bootable Asia Operating System made by Filipinos, representing a groundbreaking milestone in Southeast Asian technology development and open-source kernel innovation.

Note: This is an experimental kernel project designed for research and educational purposes. The HoloKernel pushes the boundaries of what's possible in operating system design, turning theoretical concepts into working reality.

About

holokernel

Resources

Readme
GPL-3.0 license
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages