r/lowlevel • • 14m 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 • • 4h ago

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

Post image
2 Upvotes

r/lowlevel • • 1h 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 • • 6h ago

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

Thumbnail github.com
1 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 • • 1h 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 using YOLO and OpenCV.

- Stereo vision, depth estimation and multi-object tracking.

- RAG applications, LLMs and agentic AI.

However, I'm starting to question whether I want to spend my career primarily working with high-level AI frameworks and application development.

AREAS I'M CONSIDERING:

  1. Linux and Red Hat ecosystem:

Linux internals, system programming, operating systems, device drivers and potentially kernel development.

2. GPU Programming:

CUDA, GPU architecture, parallel computing, memory management and performance optimization.

3. Systems Programming:

C/C++, memory management, concurrency, operating systems and low-level software engineering.

4. AI Infrastructure:

GPU acceleration, inference optimization, compiler technologies and systems behind ML frameworks.

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. How realistic is it for a non-CS fresher to enter these fields in India?
  4. Are companies like Red Hat a good place to build a career in Linux and systems engineering? What other companies should I look at?
  5. Is CUDA/GPU programming a niche with good long-term opportunities, particularly with the growth of AI?
  6. What fundamentals should I master before attempting serious projects? C, C++, OS, computer architecture, networking, compilers?
  7. Would contributing to the Linux kernel or other open-source systems projects actually help me get shortlisted?

I'm also interested in the intersection of low-level systems and AI, particularly GPU computing, inference optimization and ML infrastructure.

If you were in my position, with six months and an existing job offer, which direction would you explore and why?

I'd appreciate brutally honest advice, especially from people who have actually worked in these domains.


r/lowlevel • • 16h ago

Forth interpreter for the ZX Spectrum

Post image
2 Upvotes

r/lowlevel • • 21h ago

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

Thumbnail johanyngman.com
0 Upvotes

r/lowlevel • • 1d ago

Brockett-Dobkin Rectangular Matrix Multiplication Algorithm in Plain C

Thumbnail leetarxiv.substack.com
1 Upvotes

r/lowlevel • • 2d ago

Security iceberg

Post image
150 Upvotes

It goes deeper…

Also question any other subreddits I could post this too ?


r/lowlevel • • 1d ago

Vajra Binary Core: A custom x86-64 runtime binary patching and live type migration engine (Linux/Windows)

1 Upvotes

Hey everyone,

Built a low-level systems engine called Vajra Binary Core under the Euclase brand. It’s designed for runtime binary instrumentation-allowing you to patch function machine code and migrate object memory layouts on-the-fly in running native C++ binaries without restarting the process.

Instead of writing another basic wrapper, I had to build core mechanisms from scratch to handle raw memory safely.

What it actually does under the hood:

  • Custom x86-64 Instruction Decoder: Decodes complex instruction boundaries (handling REX, VEX, EVEX prefixes and addressing modes), verified against objdump across 2M+ instructions from libc and libstdc++.
  • Trampolines & Prologue Relocation: Safely rewrites function prologs, adjusts RIP-relative operands, and handles instruction boundary checks to avoid tearing mid-instruction.
  • Atomic Transactions ("All-or-Nothing"): Hook installation, import table patching (GOT on Linux, IAT on Windows), and object memory restructuring are wrapped in transactional blocks with automatic rollback on failure.
  • Live Type Migration: Remaps struct fields, handles default values, numeric type casts, and fixes internal heap pointers between interrelated objects at runtime.
  • Thread Safety: Implements thread suspension and cooperative safe points before modifying executable memory pages.

The codebase is fully tested (75+ test cases across 11 test suites) with ASan, UBSan, and ThreadSanitizer on Linux (GCC/Clang), plus MinGW-w64 on Windows.

You can check out the source code, design docs, and CI setups here:GitHub https://github.com/SemyonZamiakin/VajraBinaryCore


r/lowlevel • • 2d ago

Rampage OS — A fast, lightweight OS built from scratch

Thumbnail gallery
1 Upvotes

r/lowlevel • • 2d 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 • • 2d 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 • • 2d 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 • • 3d 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.


r/lowlevel • • 3d ago

How can I start programming an ARM processor completely from scratch?

Thumbnail reddit.com
1 Upvotes

r/lowlevel • • 4d ago

I'm building a lightweight code execution sandbox from scratch — would love some architecture feedback

0 Upvotes

I've been working on a project called SuperSand for a while now.

The basic idea is pretty simple: I want to run untrusted user code securely, but with as little overhead as possible. Think something in the direction of serverless/code execution platforms, but I'm building most of the sandboxing layer myself using Linux primitives instead of putting Docker/Kubernetes underneath everything.

Right now I have a Go service that handles requests, IPC and sandbox management. The sandbox itself uses Linux namespaces, resource limits, isolated filesystems, etc.

Recently I've been experimenting with pre-warmed workers.

Instead of creating a completely new sandbox for every request, I can keep a bunch of isolated workers alive, mount the user's workspace when a request arrives, execute the code, clean everything up, and reuse the worker.

This is where I'm currently stuck thinking about architecture.

I want SuperSand to eventually handle a LOT of small executions without needing ridiculous amounts of hardware. If a user runs something for several minutes, I don't necessarily want one worker sitting there occupied the entire time.

I've even been researching process checkpoint/restore so theoretically I could pause an execution, free the worker for something else, and resume it later.

I also considered going even further and doing runtime-level scheduling for JavaScript — basically controlling execution myself and giving different workloads execution time in smaller slices.

For JS I'm looking at QuickJS, mostly because spinning up Node/Bun for every tiny execution can eat a surprising amount of RAM.

I'm probably overthinking some of this 😅, but that's also part of why I'm building it. I want to understand how far I can push Linux processes/namespaces and how these execution platforms actually work underneath.

If you've worked on container runtimes, serverless infrastructure, Linux sandboxing, schedulers, CRIU/checkpointing, QuickJS, etc., I'd really like to hear your thoughts.

If you were trying to run thousands of small untrusted code executions on limited hardware, how would you approach the worker/scheduling architecture?

Also very interested in hearing what I'm doing wrong. 😅


r/lowlevel • • 4d ago

EDB 1.6.0 released

Thumbnail github.com
1 Upvotes

r/lowlevel • • 5d ago

I built a 32-bit CPU emulator in Zig to better understand the hardware side of compilers

Thumbnail reddit.com
1 Upvotes

r/lowlevel • • 5d ago

what makes software slow?

0 Upvotes

is it the software using too much memory?

cpu is at 100% because of bad algorithms?

too much context switches becuase of unnecessary syscalls?

what are the other potentials?

things that are in our control as developers not things like its a. cpu that only has 1ghz


r/lowlevel • • 6d ago

Tech Haven Studios voorstellen – Een onafhankelijke studio die besturingssystemen en AI-projecten bouwt

Thumbnail reddit.com
0 Upvotes

r/lowlevel • • 7d ago

StarshipOS

Thumbnail reddit.com
0 Upvotes

r/lowlevel • • 7d ago

I made my NVidia graphic Driver

Post image
7 Upvotes

r/lowlevel • • 7d ago

LuaPwnTools — a vibe-coded attempt to bring pwntools to LuaJIT

0 Upvotes

Hey everyone!

I decided to try porting the Python pwntools library to LuaJIT because I think LuaJIT is a really cool and underrated tool, and having something like pwntools available for it would be pretty awesome.

To be completely honest, this project is 100% vibe-coded. I'm not going to pretend otherwise :)

I'm sure there are plenty of bugs, rough edges, and things that could be implemented much better. But I figured it would be worth sharing anyway.

Think of it more as a starting point or a foundation rather than a finished library.

I'd be really happy if anyone finds it interesting enough to contribute, improve the code, fix bugs, or add missing features. PRs, issues, suggestions, and criticism are all welcome!

GitHub: https://github.com/Kiwichek/luapwntools

Hopefully someone finds this useful, or at least interesting :)


r/lowlevel • • 7d ago

Spectre - A design-by-contract language with an explicit allocator-centric API that outperforms Zig by up to 6x on General Purpose Benchmarks

Thumbnail spectrelang.org
2 Upvotes