Close
0%
0%

Aevros

An educational operating system kernel that explains itself through built-in introspection instead of external debuggers.

Similar projects worth following
0 followers
Aevros is an educational operating system kernel written from scratch in C and x86 assembly.

The goal is simple: instead of only telling you what happened, the kernel explains why it happened.

It records ownership and lifetime metadata as resources are created, allowing built-in tools to answer questions such as:

• Why is this process still alive?
• Who owns this allocation?
• What breaks if this resource disappears?

Current features include:

- Physical memory manager
- Buddy and slab allocators
- Paging
- Scheduler
- ELF loader
- Virtual File System (VFS)
- Interactive shell
- Allocation tracking
- Process introspection tools

The project is under active development. Networking is currently being developed separately and will be integrated once stable.

GitHub:
https://github.com/Mobeen0119/Aevros

Aevros: A Kernel That Explains Itself

Most educational kernels teach you how an operating system works. Fewer help you understand why something broke while you're experimenting.

Aevros started from that frustration. Instead of relying on external debuggers or cryptic panic messages, the kernel records information about its own state as it runs, making it possible to answer questions directly from within the system.

For example, rather than simply reporting that an allocation exists, Aevros can explain who created it and why it is still alive. Instead of printing raw page fault information, it translates the fault into a human-readable explanation. The goal is to reduce guesswork and make debugging feel more like asking questions than interpreting hex dumps.

Current features

  • x86 boot process
  • Physical memory manager
  • Buddy and slab allocators
  • Virtual memory and paging
  • Cooperative scheduler
  • ELF loader
  • Virtual File System (VFS)
  • System calls
  • Interactive shell
  • Built-in introspection tools

Introspection

The kernel records metadata when resources are created. That metadata powers commands that explain the running system rather than simply displaying raw state.

Some examples include:

  • health — overall system status
  • whyalive — explains why a process still exists
  • memstory — traces memory ownership
  • blast — shows the impact of terminating a process

The goal isn't just to inspect the kernel, but to let the kernel explain itself.

Current development

The networking stack is currently being developed separately and will be integrated once it is stable. This avoids destabilizing existing subsystems while new functionality is being built.

aevros-demo.gif

Working Commands

Graphics Interchange Format - 700.28 kB - 08/03/2026 at 04:03

Preview

  • Current Progress

    Mobeen Ahmedan hour ago 0 comments

    The core kernel is operational, including memory management, scheduling, paging, VFS, system calls, and several introspection tools.

    I'm currently building the networking stack with the same philosophy as the rest of Aevros: packets shouldn't just move through the system they should be traceable, inspectable, and able to explain where they came from, where they're going, and why.

  • Building Introspection Into the Kernel

    Mobeen Ahmedan hour ago 0 comments

    One design decision in Aevros is that state changes shouldn't happen silently.

    When memory is allocated or resources are created, the kernel records ownership and lifetime metadata alongside them. That information powers commands that explain what the system is doing instead of simply dumping internal structures.

    The goal isn't to replace traditional debugging tools. It's to make the operating system capable of describing its own behavior from inside the shell.

  • Why I Started Building Aevros

    Mobeen Ahmedan hour ago 0 comments

    Most hobby kernels teach operating system concepts well, but when something breaks, you're usually left staring at register dumps or adding temporary print statements everywhere.

    I wanted something different.

    The idea behind Aevros is simple: if the kernel already knows what it's doing, why shouldn't it be able to explain that?

    That idea became the foundation of the project. Instead of relying only on external debugging tools, the kernel records metadata about resources as they're created and uses that information to answer questions about its own state.

    It's still a work in progress, but every subsystem is built with the same question in mind:

    Can the kernel explain why this exists and what happens if it disappears?

View all 3 project logs

Enjoy this project?

Share

Discussions

Does this project spark your interest?

Become a member to follow this project and never miss any updates