r/lowlevel • • Oct 13 '26

I built a 3D Linux process inspector using Rust, eBPF, and ptrace

486 Upvotes

ProcInSh is a web-based process inspector for Linux.

Inspired by Ghost in the Shell, it lets you wander through process space with your ghost.

ProcInSh lets you explore what's happening inside your Linux system through interactive 3D graphics.

It visualizes running processes, inter-process communication, file I/O, external network connections, and process tree structures. Processes glow when they run on a CPU.

The backend is written in Rust and collects information from several Linux interfaces:

  • procfs

  • eBPF

  • ptrace

  • perf_event_open

The frontend is written in TypeScript and Three.js.


r/lowlevel • • Oct 16 '25

Hey guys! I have made a project called ESPionage which can be used for reverse engineering and firmware analysis of ESP8266 and ESP32 based chips.

Post image
385 Upvotes

I along with one of my friend made this project.
GitHub : https://github.com/serene-brew/ESPionage
Do give it a star if you like it and we welcome all contributors


r/lowlevel • • Oct 18 '25

I made this project called NullSwitch for wifi pentesting. Support and drop a star :D

Thumbnail
gallery
254 Upvotes

Currently the firmware is compatible for esp8266 (nodemcu) however you can build the firmware for your own chipset. It has a shell (the command line) and auth system (looks cool). As of now, it can discover active clients in a network, packet monitoring and beacon attack (that was the easy part lol)
Future plans are to implement the evil twin and deauth (i need help T_T) and probably a lightweight ftp server.

It will be helpful if like minded people like you take interest in this and contribute :D

Drop a star if you like what you see
GitHub Link: https://github.com/mintRaven-05/NullSwitch


r/lowlevel • • 2d ago

Security iceberg

Post image
141 Upvotes

It goes deeper…

Also question any other subreddits I could post this too ?


r/lowlevel • • 14d ago

I build an OS

Thumbnail
gallery
124 Upvotes

i just got APIC, IDT keyboard, context switching and lz4 compresser and decompresser
Github: https://github.com/NoTheIdiot/WindogeOS


r/lowlevel • • May 29 '26

anyone here working on weird low-level projects?

79 Upvotes

anyone else here really into low-level/systems stuff?

compilers, OS dev, emulators, kernels, RTL, architecture, linux internals, C/Rust/Zig/asm, all that rabbit hole.

don’t really know many people into this kind of thing and thought it’d be cool to meet others who are. mostly just looking to talk tech, share ideas, maybe build some projects together at some point.

apparently the number of teenagers voluntarily reading ISA docs instead of touching grass is lower than expected.


r/lowlevel • • May 06 '26

Web Server written entirely in ARM64 assembly for MacOS

Thumbnail
github.com
71 Upvotes

r/lowlevel • • Nov 22 '20

Booting PC from a vinyl record

Thumbnail
boginjr.com
58 Upvotes

r/lowlevel • • Aug 24 '26

I made a programming game where you control the CPU's internals directly instead of writing assembly

56 Upvotes

r/lowlevel • • Oct 31 '21

I attempted to diagram everything I've learned about the problem-set of endpoint threat recognition over the past 2 years of research. Anything wrong so far? (Part 2)

Post image
56 Upvotes

r/lowlevel • • Aug 14 '17

An Intro to Compilers

Thumbnail
nicoleorchard.com
52 Upvotes

r/lowlevel • • Oct 07 '26

dtask, a TUI task manager

Thumbnail
gallery
50 Upvotes

Been working on dtask, a terminal task manager I originally wrote in C. Spent a little over a week porting it to D.

There is a self terminal input and rendering, including mouse controls, drag and drop, and handling Unicode without messing up the layout. Everything is saved locally, and it’s tested on Linux, macOS and FreeBSD (Unix systems support).

github.com/GuestAUser/dtask


r/lowlevel • • Aug 11 '26

PS1 Style Renderer in C

49 Upvotes

r/lowlevel • • Jun 21 '15

M/o/Vfuscator - The single instruction C compiler - compiles programs into "mov" instructions, and only "mov" instructions.

Thumbnail
github.com
49 Upvotes

r/lowlevel • • Dec 01 '17

Writing a C Compiler, Part 1

Thumbnail
norasandler.com
45 Upvotes

r/lowlevel • • Dec 14 '25

Thread-safe B-Tree implemented in pure x86-64 assembly – 58k mixed ops/sec under contention. I've just finished a complete, generic B-Tree written entirely in hand-tuned x86-64 assembly (NASM) with a clean C interface as a shared library.

44 Upvotes

Key points: Full insert/delete with split, merge, borrow, and root shrinking

Thread-safe using pthread_rwlock (reader/writer lock)

Contiguous node layout (child pointers + objects in one block) for better cache behavior

Minimum degree 511 → large nodes, low height

Includes multithreaded stress demo (8 threads concurrent insert + delete)

Benchmark on my 2021 Dell XPS 15 (i7-11800H, 8c/16t): 8.4 million mixed insert/delete operations

Average ~143 s wall time across runs

~58,800 ops/sec sustained under heavy rebalancing contention

Single global rwlock – deliberately conservative for correctness. Survives real splits/merges while other threads hammer it.Repo: https://github.com/KatoKode/BTree_MT Build & run the demo:

git clone https://github.com/KatoKode/BTree_MT.git

cd BTree_MT-main/

sh btree_make.sh

cd ./demo

./go_demo.sh

Feedback welcome, especially on further optimizations or real-world embedded use cases.(Open to systems/embedded/firmware roles where low-level performance matters.)Thanks!


r/lowlevel • • Aug 19 '19

Sushi Roll: A CPU research kernel with minimal noise for cycle-by-cycle micro-architectural introspection

Thumbnail
gamozolabs.github.io
42 Upvotes

r/lowlevel • • Feb 15 '26

How Michael Abrash doubled Quake framerate

Thumbnail fabiensanglard.net
41 Upvotes

r/lowlevel • • Mar 19 '19

Dozens of minimal operating systems to learn x86 system programming

Thumbnail
github.com
41 Upvotes

r/lowlevel • • Mar 18 '16

BinDiff now available for free

Thumbnail
security.googleblog.com
40 Upvotes

r/lowlevel • • Sep 19 '15

What Does an Idle CPU Do?

Thumbnail
duartes.org
39 Upvotes

r/lowlevel • • Mar 23 '21

Speculating the entire x86-64 Instruction Set In Seconds with This One Weird Trick

Thumbnail
blog.can.ac
37 Upvotes

r/lowlevel • • Dec 26 '19

My Business Card Runs Linux

Thumbnail
thirtythreeforty.net
37 Upvotes

r/lowlevel • • May 06 '17

The Windows debugger team is hiring!

37 Upvotes

I'm a dev lead for the Windows debugger team at Microsoft and I wanted to let you all know that we have positions available on our team. Our team works on WinDbg and related tools around user and kernel debugging. We're doing a lot of work around making debugging easier and more powerful, as well as improving the ability to do automatic problem analysis. It's a good fit for anyone interested in low level code.

The job description and application link is here: https://careers.microsoft.com/jobdetails.aspx?ss=&pg=0&so=&rw=1&jid=283606&jlang=EN&pp=SS


r/lowlevel • • Jun 12 '26

I'm building a modern, pure-Rust reimplementation of rsync (Protocol 32). Here is the architecture and the story behind it.

34 Upvotes

The Motivation

Years ago, I was tasked with a massive data migration: multiple disks, each containing over 100 million files, with a strict, non-negotiable 24-hour downtime window. Using the standard tools available at the time was an incredibly painful experience. The single-threaded file discovery crawled, and memory usage was a constant anxiety. I promised myself that one day, I would come back and build a tool that could actually handle that scale natively without choking.

The Project: oc-rsync

GitHub Repository: oferchen/rsync

What started as a revenge-driven side project has evolved into a full systems-level undertaking. oc-rsync is a complete client, server, and daemon implementation targeting rsync protocol 32, written entirely in pure Rust.

I find it incredibly ironic that I am currently shipping a data migration tool while my life is packed in suitcases, literally migrating to another country myself. I’ve been pushing git commits multiple times a day between packing boxes.

Architecture & Systems Engineering

Rebuilding a codebase shaped by over 20 years of optimization required a highly modular approach (the workspace is currently split across 23 crates). A primary engineering goal was strict wire-compatibility with upstream rsync while modernizing the internals for maximum throughput.

Some of the key architectural decisions:

  • Pipelined Parallelism: I used Rayon to decouple filesystem traversal from data transfer. Parallelizing file list generation and checksum computation eliminates the infamous "scanning stall" on massive directories.

  • Modern I/O & Zero-Copy: The engine implements io_uring (Linux 5.6+) for batched async I/O with automatic fallbacks, alongside zero-copy copy_file_range and memory-mapped I/O (mmap).

  • SIMD & AES-NI Offloading: I replaced the standard C FFI calls with native Rust implementations. Checksums use runtime CPU feature detection (AVX2/NEON) to accelerate the rolling hash. Furthermore, because standard SSH interactions simply weren't fast enough to keep up with the I/O pipeline, I went ahead and offloaded the cryptography directly to hardware-accelerated AES-NI.

  • Memory Efficiency: Moved away from legacy sorted arrays to O(1) hash-based logic for metadata comparisons, and wired up the mimalloc allocator to keep the memory profile predictable during high-concurrency transfers.

Performance

I won't commit to specific "X times faster" claims here, as performance is highly dependent on your hardware, network, and file distribution. However, under heavy transfer workloads, this architecture consistently achieves better or equal results compared to traditional builds, with significantly reduced CPU utilization.

There's no need to set up benchmark scripts yourself to verify this - my CI pipeline benchmarks every single release automatically and posts a picture of the results directly to the README.md on GitHub.

Current Status (Disclaimer)

I want to be completely transparent: I am actively working on this, and not everything is functional yet. While the core delta-transfer, protocol interoperability (protocols 28-32), and daemon modes are solid, I am still mapping out the hundreds of obscure flags and edge-cases that upstream rsync handles. It's under heavy development, and I’m pushing commits multiple times a day to stabilize the defensive coding and edge cases.

If you are interested in systems programming, kernel bypass I/O, or Rust workspace architecture, I'd love for you to take a look at the code.

Repo: https://github.com/oferchen/rsync

Let me know what you think of the architecture, or if you spot any glaring filesystem edge cases I should add to my CI harness!