r/lowlevel • • 5h ago

SysArmor: A lightweight Linux system hardening tool written in pure C and Assembly (zero dependencies)

0 Upvotes

Hey everyone! I built **SysArmor**, a zero-dependency system hardening and security miffing tool written entirely in pure C and Assembly.

It uses POSIX system calls (like `open` with `O_NOFOLLOW` and `fstat`) to protect critical system paths against symlink attacks, race conditions, and unauthorized modifications across all standard Linux distros (Ubuntu, Debian, Fedora, Arch, etc.).

If you're into low-level systems programming, terminal utilities, or want to check it out, the repository is here:

👉 **https://github.com/error0941/sysarmor**

I’d love to hear your feedback, code reviews, or suggestions!


r/lowlevel • • 5h ago

SysArmor: A lightweight Linux system hardening tool written in pure C and Assembly (zero dependencies)

0 Upvotes

Hey everyone! I built **SysArmor**, a zero-dependency system hardening and security tool written entirely in pure C and Assembly.

It uses POSIX system calls (like `open` with `O_NOFOLLOW` and `fstat`) to protect critical system paths against symlink attacks, race conditions, and unauthorized modifications across all standard Linux distros (Ubuntu, Debian, Fedora, Arch, etc.).

If you're into low-level systems programming or terminal utilities, the repository is here:

👉 **https://github.com/error0941/sysarmor**

I’d love to hear your feedback, code reviews, or suggestions!

NOT:Başlıkta Assembly yazmışım ama şu anki sürüm tamamen saf C ve POSIX sistem çağrıları ile çalışıyor. İlerleyen sürümlerde kritik syscall'lar için inline assembly ekleyeceğim.

NOT:Assembly eklenmiştir.


r/lowlevel • • 1d ago

Phrack 73 is live!!!

Thumbnail phrack.org
5 Upvotes

r/lowlevel • • 22h ago

Check out everything over on github

Post image
0 Upvotes

Link on my page


r/lowlevel • • 1d ago

V5 has passed a important test

Thumbnail reddit.com
0 Upvotes

r/lowlevel • • 1d ago

Progress

Post image
0 Upvotes

r/lowlevel • • 22h ago

"I'm building my own 64-bit operating system using an Android phone — Introducing HELLCORE OS and its long-term vision.

Thumbnail gallery
0 Upvotes

r/lowlevel • • 1d ago

A few screen shots

Thumbnail gallery
0 Upvotes

r/lowlevel • • 1d ago

With zero prior coding experience, I've been putting in 6:00 AM to 3:30 AM days building a freestanding x86-64 gaming OS kernel from scratch on a Samsung Galaxy A26 using Termux, Clang 21, QEMU 10.2, and ChatGPT — showing what happens when you use AI the right way

0 Upvotes

I'm DJ Lucifer. Coming into this with zero prior coding experience, I've spent the past 16 days (Nov 2 – Nov 17, 2026) starting every morning at 6:00 AM and coding until 3:30 AM—building HELLCORE OS, a freestanding, clean-slate gaming operating system, 100% on a Samsung Galaxy A26 smartphone using Termux, Clang/LLVM 21.1.8, LLD 21.1.8, and QEMU 10.2.1, with ChatGPT as my AI coding assistant and teacher. A massive thank you to the creators of ChatGPT—without your work making an AI pair-programmer and teacher accessible directly from a smartphone, someone with zero coding background building, debugging, and runtime-verifying a 64-bit operating system from scratch on a budget phone without a desktop workstation wouldn't have been possible. And a huge thank you to Bill Gates for being a big inspiration—knowing how he started out writing low-level code for constrained early hardware without even having the physical machine in front of him inspired me to push past having zero workstation gear and start building an operating system right on the phone in my pocket.

Why This Is How to Use AI Correctly

A lot of people think using AI to code means blindly copy-pasting broken snippets and hoping for the best. This project is proof of how to use AI the right way: • AI Guides, Hardware Verifies: Every single module is compiled with strict -Wall -Wextra -Werror flags, audited symbol-by-symbol with llvm-nm and readelf, and booted live inside QEMU 10.2.1 with serial register dumps and fault-injection tests. • Zero Blind Trust: Nothing moves forward until it passes runtime assertions, restores exact physical memory counts, and gets locked into a SHA-256 milestone manifest. When you pair human discipline and rigorous testing with AI as a teacher and force multiplier, you can learn low-level systems engineering from the ground up and build things people say are impossible. No PC or laptop—every .efi loader, linker script, kernel C file, SHA-256 manifest, and QEMU test harness has been written, compiled, and booted straight from my phone.

What's Built & Verified Right Now (Nov 2 – Nov 17, 2026)

  1. Custom UEFI Bootloader (BOOTX64.EFI): • Evolved across 27 .efi builds from a 2.5 KB prototype into a hardened 13 KB loader that parses ELF64 program headers, loads segments into 0x101000, zeroes .bss, captures ACPI 2.0 RSDP (0x1F77E014) and the GOP linear framebuffer (0x80000000, size 0x3E8000), reserves kernel/stack/PMM bitmap regions, calls ExitBootServices(), and hands off HELLCORE_BOOT_INFO to kernel_main.
  2. Physical Memory Manager (PMM): • Bitmap allocator managing 0x1CC93–0x1CDFA usable pages across UEFI memory ranges, blocking double-frees (hellcore_pmm_free_page() returns 0 on duplicate/protected frames) and protecting kernel/stack memory (verified with a 64-page allocation/release/reuse stress test).
  3. Live CR3 Virtual Memory Takeover (CORE 1.0): • Walks inherited OVMF page tables (0x1F801000), validates 10 critical runtime addresses, allocates a kernel-owned PML4 root at 0x00110000, switches CR3 live, and verifies 10/10 post-switch mappings.
  4. Atomic Private Page Tables (V3 & V4 — Both Live-Verified in QEMU 10.2.1): • Bottom-up PDPT → PD → PT allocation before parent entry publication, strict W^X enforcement (WRITE + EXECUTE rejected), higher-half PML4 slot ownership guards, multi-branch PD/PT mappings, and atomic rollback on injected allocation failures (test_fail_after)—with all milestones SHA-256 archived and verified intact.
  5. Live CR3 Virtual Memory Takeover (CORE 1.0): • Walks inherited OVMF page tables (0x1F801000), validates 10 critical runtime addresses, allocates a kernel-owned PML4 root at 0x00110000, switches CR3 live, and verifies 10/10 post-switch mappings.
  6. Atomic Private Page Tables (V3 & V4 — Both Live-Verified in QEMU 10.2.1): • Bottom-up PDPT → PD → PT allocation before parent entry publication, strict W^X enforcement (WRITE + EXECUTE rejected), higher-half PML4 slot ownership guards, multi-branch PD/PT mappings, and atomic rollback on injected allocation failures (test_fail_after)—with all milestones SHA-256 archived and verified intact.
  7. Active Now (CORE 1.0 V5 — Bottom-Up Page-Table Reclamation): • Extending the V4 ownership model so unmap_page() recursively detects empty PT, PD, and PDPT tables, unlinks parent entries before releasing child frames, invalidates TLBs, and returns every freed table frame cleanly back to the PMM (owned_tables → 0, tables_reclaimed → 6).

Live QEMU 10.2.1 Serial Output From My Galaxy A26

text HELLCORE CORE 1.0 SAFE VMM TAKEOVER SAFE VMM ROOT ALLOCATED OLD CR3: 0x000000001F801000 NEW CR3: 0x0000000000110000 SAFE VMM CR3 SWITCH AND READBACK PASSED SAFE VMM POST-SWITCH MAPPINGS: 10/10 PASSED

HELLCORE CORE 1.0 PRIVATE VMM V4 TESTS CORE 1.0 V4 TEST PASSED: V4 initialization CORE 1.0 V4 TEST PASSED: private PML4 slot reservation CORE 1.0 V4 TEST PASSED: unreserved PML4 mapping rejected CORE 1.0 V4 TEST PASSED: first private mapping CORE 1.0 V4 TEST PASSED: new PD rollback restores PMM statistics CORE 1.0 V4 TEST PASSED: new PT rollback restores PMM statistics CORE 1.0 V4 TEST PASSED: new-PT address translation

HELLCORE CORE 1.0 SAFE VMM TAKEOVER SAFE VMM ROOT ALLOCATED OLD CR3: 0x000000001F801000 NEW CR3: 0x0000000000110000 SAFE VMM CR3 SWITCH AND READBACK PASSED SAFE VMM POST-SWITCH MAPPINGS: 10/10 PASSED

HELLCORE CORE 1.0 PRIVATE VMM V4 TESTS CORE 1.0 V4 TEST PASSED: V4 initialization CORE 1.0 V4 TEST PASSED: private PML4 slot reservation CORE 1.0 V4 TEST PASSED: unreserved PML4 mapping rejected CORE 1.0 V4 TEST PASSED: first private mapping CORE 1.0 V4 TEST PASSED: new PD rollback restores PMM statistics CORE 1.0 V4 TEST PASSED: new PT rollback restores PMM statistics CORE 1.0 V4 TEST PASSED: new-PT address translation

The Ultimate Endgame for HELLCORE OS

I know this is a massive multi-year climb—especially starting with zero coding experience—so I'm building it brick by brick from the kernel up, with the ultimate goal of turning HELLCORE OS into a cross-architecture (x86-64 PC/laptop + ARM64/Snapdragon handheld & mobile) gaming and creator platform featuring:

• Zero-Bloat Gaming Core: Deterministic low-latency frame pacing, 4K/8K HDR display pipeline, and direct hardware performance controls with zero background telemetry. • Modern Gaming & Cloud Support: Compatibility layers and hardware video/audio pipelines built for Steam, Unreal Engine, VR, GeForce NOW, and Xbox Cloud Gaming. • Built-In Creator & Media Studio: Native DJ mixing software, a custom media player, and an integrated live streaming studio sharing the same lock-free low-latency audio engine and hardware video decoders.

• Native AI Assistant (Jarvis): Voice-assisted system control, hardware tuning, and real-time assistance integrated directly into the OS.

Special thanks again to Bill Gates, the creators of ChatGPT, and the Termux team for the inspiration and tools that let someone with no coding background turn a smartphone into a bare-metal OS development lab. Happy to share the linker script, page-table rollback/reclamation logic, or Termux cross-compile setup if anyone wants to see how it runs on mobile!


r/lowlevel • • 1d ago

I wrote a ProtectServer FM in Zig and skipped the vendor compiler

Thumbnail 808bits.com
1 Upvotes

r/lowlevel • • 1d ago

made my own os from scratch and it runs real linux programs (not clickbait)

0 Upvotes

it’s called kurono, and nothing in it is borrowed so like the kernel, the desktop, the compositor, the hypervisor, the drivers, all is written from scratch

the part i’m proudest of is the linux layer. kurono answers linux syscalls itself, so stock linux binaries run on it without being recompiled or patched. firefox 140 esr runs fully multi-process, with content processes, ipc over unix sockets passing fds around, futexes, epoll, all of it. bash, gcc, make and node all run too, and linux gui apps draw through a wayland server i wrote myself (kind of like wsl1 which microsoft dropped)

drivers are where it gets crazy. instead of rewriting every driver, i take the real upstream linux driver source, compile it unmodified, and run it as an isolated ring 3 container on top of my own linux kernel api emulation, fenced off by the iommu. intel wifi (iwlwifi) actually connects on a real be200 card this way, and if a driver crashes it gets restarted instead of taking the system down (Still working on GPU driver's)

it has its own hypervisor too, built on vt-x. it boots debian or alpine (or it can reboot kurono OS inside itself) in the background with 4 vcpus (Or more!) and sound, and their apps open as normal windows right on my desktop next to native ones. it can even pass the laptop’s nvidia gpu straight through to the debian guest with vt-d

it’s self-hosting as well. kurono can compile its own kernel and uefi loader with gcc 14 inside itself, install it as a trial boot, and roll back automatically if it doesn’t make it to the desktop

kernel side: smp across every core, x2apic, copy-on-write fork, demand paging, its own filesystem plus ext4/fat32/ntfs, a crash path that saves records across reboots, and a recovery mode with repair tools built in

and it’s not a qemu-only toy (Noticed a bunch on this sub-reddit but they are really cool IMO), it runs on real hardware: a 20-core arrow lake laptop with every core online

about 370k lines of code so far. right now i’m tearing out the big kernel lock piece by piece, and the kernel lock contention is already down 95%. next up is locking the desktop at a smooth 240fps, i didn't push this to the public repo right now but i will soon,

I used alot of the break periods to build this OS and once I get more stable with money ill buy some other machines and try to push support so it can work on many machines (mainly trying to enhance kld to work on most machines rather then try to support every computer in the world from a non-existant driver-system). also for the memory people wondering, kurono idles at 420-450 MB ram (video it shows higher because linux, firefox and opencode ran on it and some memory leaks) on desktop, im trying to bring it down to 50mb but the 420mb is mainly my monitors running at full resolution (to achive that low of ram usage i will have to mature KmemX, but its very unstable and unpredictible so i have it off by default)

Website: amanaric.org/kurono
Github: github.com/darkside7925/kurono
(all the details are on this site about kurono)

here's a video though, it isn't polished fully and this is the experimental phase, so some minor or major bugs can show in it, and the video doesn't show everything


r/lowlevel • • 2d ago

NvRoot (CVE-2026-47591) where in neocloud multi-tenant GPU environments, rent = root.

1 Upvotes

Essentially it's a dirty page cache LPE using GPUs as catalyzer.

From unprivileged user to root. Most dangerous for those renting multi-tenanted GPU from a neocloud.

Fixed versions: NvRoot in 610.57.04 / 595.91.07 / 580.178.04

no sysctl or seccomp workaround.

More details here: stealthium.io/blog/nvroot

Disclaimer: I work at Stealthium, alongside the team that found these. Happy to answer questions on exposure


r/lowlevel • • 2d ago

Built a low-level systems programming language from scratch to crush concurrency bottlenecks—benchmarks inside.

Post image
2 Upvotes

r/lowlevel • • 2d ago

Recovering an x64 call hidden inside a mov: A reproducible IDA Pro vs RESX comparison

Thumbnail github.com
3 Upvotes

Hiya,

I've been building RESX, an open-source Windows binary analysis and reverse engineering toolkit written in Rust.

It started as a small side project to make reversing Windows binaries less painful, and it's grown a fair bit since then. Most of my time has gone into instruction decoding, control-flow reconstruction, Windows internals, syscalls and kernel analysis.

One problem I've spent a lot of time on is overlapping x86/x64 instruction streams. A branch can land in the middle of another instruction, so the same bytes decode as two completely different streams. If the disassembler commits to one of them, it can miss real control-flow edges.

I made a small, reproducible test case for this. The compiled binary and its assembly source are in the repo, so you can try it yourself. It's deliberately constructed and benign.

IDA Pro

In the sample, the branch at 0x140001009 targets 0x14000100F, which is two bytes into a 10-byte mov r11, imm64.

IDA Pro 9.0 with default auto-analysis gives:

140001009  jz   short near ptr loc_14000100D+2
14000100B  jmp  short $+2
14000100D  mov  r11, 9F08EB0000000FE8h
140001017  mov  eax, 0C0000022h
14000101C  jmp  short $+2
14000101E  retn

The branch goes to 0x14000100F, but IDA has already claimed those bytes as part of the mov. Default analysis never decodes the call hidden there, so the edge to HiddenTarget is lost.

IDA does still find HiddenTarget on its own, but only because the fixture exports that name. The call that leads to it never shows up.

RESX

Same binary, no PDB:

> resx dump .\resx\tests\data\overlap_probe.exe OverlapProbe --bytes --calls --no-pdb --no-color

00001009  74 04                          je    short 0x14000100f
0000100b  eb 00                          jmp   short 0x14000100d
0000100d  49 bb e8 0f 00 00 00 eb 08 9f  mov   r11, 0x9f08eb0000000fe8
0000100f  e8 0f 00 00 00                 call  HiddenTarget

API Call Map for OverlapProbe  [1 call site(s)]:
  └── 0x100F  CALL  HiddenTarget

RESX keeps both decode streams, finds the call sitting inside the mov, and follows the edge to HiddenTarget.

To be fair to IDA: this compares default automatic analysis on a sample built to trigger exactly this case. It doesn't mean IDA can't recover the path with some manual work.

What else it does

Beyond decoding, RESX can:

  • Trace Windows APIs through the system DLLs and into the kernel.
  • Recover syscall numbers and reconstruct API arguments.
  • Name APIs that are resolved by hash or encoded name.
  • Analyze kernel driver IOCTLs.
  • Follow possible ETW-TI telemetry paths.

There's also CFG reconstruction, binary diffing, corpus hunting and a VS Code extension, with more documented in the repo.

All of it is static: it works from file bytes and optional symbols and never runs the target.

It's still under active development, and I'd really like to hear what other reversers and low-level devs think, especially if you manage to break the decoder or catch it getting something wrong.

GitHub: https://github.com/Ryftenius/RESX


r/lowlevel • • 2d ago

Got placed, have 6 months before joining. Should I explore Linux kernel development, GPU programming or stick with AI/ML?

Thumbnail reddit.com
0 Upvotes

r/lowlevel • • 2d ago

Got placed, have 6 months before joining. Should I explore Linux kernel development, GPU programming or stick with AI/ML?

0 Upvotes

I'm a final-year engineering student in India from a non-CS background. I've recently secured an offer at an AI/analytics services company, and I have around 6 months before joining.

I've been exploring different areas of computer science, and I've realized that I'm increasingly interested in low-level programming and understanding how systems work internally.

MY BACKGROUND:

I've independently learned programming, ML/DL and worked on projects involving: computer vision , RAG , agentic AI

However, I dont want to spend my career primarily working with high-level AI frameworks and application development. because when i developed these projects , i didnt feel anything developing it , no satisaction at all

AREAS I'M CONSIDERING:

  1. Linux and Red Hat ecosystem:
  2. 2. GPU Programming:
  3. 3. Systems Programming
  4. 4. AI Infrastructure:

I find the idea of understanding what happens beneath the abstractions much more interesting than simply using existing libraries.

WHAT I'M CONFUSED ABOUT:

I have six months before joining my company, and I don't want to waste that time jumping between technologies.

I'd appreciate advice from people working in systems engineering, Linux, kernel development, GPU programming or related fields.

  1. Is low-level systems programming a good career direction in 2026?
  2. Between Linux kernel development, GPU programming and general systems programming, which would be a better starting point?
  3. Is CUDA/GPU programming a niche with good long-term opportunities, particularly with the growth of AI?
  4. What fundamentals should I master before attempting serious projects? C, C++, OS, computer architecture, networking, compilers?
  5. Would contributing to the Linux kernel or other open-source systems projects actually help me get shortlisted?

r/lowlevel • • 2d ago

Forth interpreter for the ZX Spectrum

Post image
3 Upvotes

r/lowlevel • • 2d ago

Fireface UCX on Linux: reverse engineered and built with Claude Code

Thumbnail johanyngman.com
0 Upvotes

r/lowlevel • • 3d ago

Brockett-Dobkin Rectangular Matrix Multiplication Algorithm in Plain C

Thumbnail leetarxiv.substack.com
1 Upvotes

r/lowlevel • • 4d ago

Security iceberg

Post image
201 Upvotes

It goes deeper…

Also question any other subreddits I could post this too ?


r/lowlevel • • 4d ago

Rampage OS — A fast, lightweight OS built from scratch

Thumbnail gallery
1 Upvotes

r/lowlevel • • 4d ago

v2.2.1 is ready!

Thumbnail reddit.com
0 Upvotes

Tons of improvements have recently hit the deck, ready to be checked out and tinkered with! We are now fully self hosted and no longer require LLVM or Python post bootstrap.

Before we get to those upgrades though, a quick note, the language was renamed to Ideka due to discoverability issues with the name Flux.

First up, we now have full support for both x86_64 and ARM64.

Secondly, we have a brand new thread-safe version of the standard heap allocator!

We’ve fixed a codegen bug that was breaking SHA384, as well as expanded the cryptography library significantly. This upgrade was followed by the addition of a full native TLS v1.3 implementation as well.

Third, Discord bots, anyone? Yes, Discord.IDK has arrived. While still in beta, the library allows you to do most basic things save for interactions and a handful of other features.

And last but not least, SQLite is nearing completion and will be released within the next 6-8 hours.

We hope you enjoy all the new changes!

Get the compiler at GitHub


r/lowlevel • • 5d ago

Decoupled offline formal refinement for #![no_std] Rust (Charon + Aeneas + Coq 8.18.0 in a --network none OCI airlock)

Thumbnail reddit.com
0 Upvotes

Crossposting from r/cursor — sharing the MIT template (trencinodin-stack/arcstone-airlock-blueprint) for anyone verifying bare-metal #![no_std] Rust crates without pulling solver/nightly toolchains into the upstream crate.


r/lowlevel • • 5d ago

Bursztyn OS: How I taught my operating system to write in Arabic, display color emojis, and not run out of memory in the process

0 Upvotes

Building your own operating system from scratch isn't just about adding cool features. Above all, it’s about checking what runs too slowly, where space is running out, and making sure nothing crashes when writing to disk. I just completed a major review of the recent changes to the text rendering engine (BSF) in Bursztyn OS.

The progress is huge, but before I consider this stage complete, I need to tie up a few important loose ends. Here is what has been accomplished and what is currently on the workbench:

1. One text engine instead of separate workarounds (BSF 2.1)

Until now, different programs handled text in their own ways. Now, Notepad, the system UI, and my browser, Husarz, all share a single, unified mechanism:

  • Right-to-left script (Arabic, Hebrew): Paragraphs align properly to the right, letters connect as they should, and the cursor and text selection work naturally—even when Polish and Arabic are mixed within the same sentence.
  • What still needs improvement: In the Husarz browser, standard Polish and English pages currently load about 10–15% slower. We are also still missing column reversal in Arabic tables, text selection directly on web pages (it currently works only in form fields), and smoother cursor movement when jumping between paragraphs in Notepad.

2. Modern fonts and color emojis (BSF 2.2) Bursztyn OS now supports much more than just basic fonts:

  • Professional fonts (OTF/CFF), large font collections (e.g., for Asian languages), and web fonts (WOFF/WOFF2) fetched by the browser are now working.
  • The system can also display color emojis and variable fonts (where you can smoothly adjust letter weight).
  • Settings now include an option to choose a separate font specifically for the Terminal.

3. Two major optimizations "under the hood"

  • Recovered nearly 4 MB of space in the system kernel: The kernel image has a strict 15 MB limit. After adding the new features, only 388 KB of headroom remained—things were getting tight. It turned out that the 22 built-in system applications were taking up the most space. I compressed them using the zlib algorithm and wrote a mechanism in the kernel that unpacks them in small chunks at startup. Free headroom jumped back up to 4.3 MB.
  • Over 8x faster font rendering: It turned out that rendering certain fonts took too long not because of file-reading bugs, but due to slow square-root calculations when drawing curved letter outlines. I replaced the old calculations with a single CPU instruction (SSE2) and added caching. The result? Character rendering sped up by 8.3x while maintaining 100% sharpness and compliance with the FreeType standard.

4. What's next? Disk safety comes first The text engine has passed hundreds of thousands of automated tests and runs stably on virtual machines (UEFI and BIOS). Nevertheless, I am holding off on the final merge because data-write reliability is more important right now:

  • Installer issue: During a full system installation to disk, random write timeout errors (VirtIO-BLK request timed out) occur. Before moving forward, I need to thoroughly inspect the disk driver and task queuing to ensure the installer never corrupts files.
  • Cleanup and live testing: I also need to free up space on my working drive, organize files in the repository, and test installing massive font packages (over 16 MB) directly inside the running system.

Only once the installer and disk work flawlessly will I move on to the next features: sliders for adjusting font weight in Settings and support for Indic scripts (Devanagari).

#BursztynOS #OSDev #Programming #LowLevel #Cpp #PolishSoftware #OperatingSystem


r/lowlevel • • 5d ago

Emulating a Realtek RTD2841 Smart TV SoC in QEMU: MMIO, GIC-400, and booting a vendor 4.4 kernel

1 Upvotes

I built a custom QEMU system model for the Realtek RTD2841 (RTK284x series) SoC, targeting the TCL RT41 chassis (tv030).

The SoC runs a quad Cortex-A53 in AArch32 mode. The emulator implements the MMIO peripherals needed to boot the stock vendor Linux 4.4 kernel and run userspace binaries:

  • Interrupts: ARM GIC-400 distributor and CPU interfaces (0x18081000 / 0x18082000).
  • Timers: 27 MHz system timer block (TC0) at 0x1801B600, with hardware down-counters mapped to monotonic reads for Linux sched_clock and INTID 34 IRQ delivery.
  • Storage: Synopsys DesignWare SDHCI eMMC controller at 0x18010800, wired to QEMU SD media drives.
  • Networking: RTL8168 gigabit Ethernet controller (0x18016000) with TX/RX DMA descriptor rings connected to a SLIRP backend for outbound DNS and HTTP traffic.
  • Graphics / Shaders: Freestanding EGL 1.4 / GLES 2.0 software driver with an integrated SwiftShader AST compiler frontend (TCompiler) for strict GLSL ES 1.00 validation without host Mali dependencies.

The repo includes a bare-metal diagnostic suite written in pure ARM32 assembly (tests/firmware_test.s, assembled via arm-none-eabi-as) that checks CPU modes, GIC INTID delivery, timer tick rates, eMMC presence, and Ethernet loopback before passing execution to the kernel.

Source, device tree sources, and test harnesses:
https://github.com/rubenthampy890-del/qemu-rtd2841

Feedback on the MMIO models and register maps is welcome.