Hello everyone,

I have been using eBPF/XDP for the past 5 years and was always a little frustrated by the lack of tooling when it comes to see what is happening underneath, especially when debugging deployed eBPF programs. Here I am sharing a tool I have been using for a couple of months now but only made public recently: ebpfexplorer.

It's a simple TUI self contained binary, that allows you to explore all eBPF programs & maps attached to your kernel. It comes with a formatting tool that allows you to format the raw binary blob into human readable symbols (like IPs for instance), using C type format.

Please have a look and feel free to propose PRs. Hope you find it useful too.

Hey everyone I’ve been experimenting with low-level systems programming in Rust and built a tiny, #!\[no_std\] lock-free map using atomic CAS and open addressing. First time sharing an open source systems project, I’d love to hear your thoughts or code critiques! ❤ the link https://github.com/voryiex/Titan-Cache-Engine

just a thought - devs with experience , please help me out atp

Hey everybody, I was taking a course in Embedded Operating Systems, and since my primary way of taking notes is Obsidian, I found it pretty annoying to deal with it since it’s missing some basic stuff like highlighting for ARM or RISC-V, and also dealing with memory maps and registers.

So I vibecoded a plugin to fix this small niche issues, it has some pretty comfy features, with hover cards for instructions and conversion of numbers in different basis, diagrams and also syntax for other smaller things such as Makefile, Linker Script, Verilog etc…

I wanted some opinions from external users, and thought that could be useful for the few people in my situation

Any tips or recommendations are welcome!

Instead of pointer-chasing through B-Tree node hierarchies, this index models the key distribution using streaming piecewise linear regression with strict epsilon error bounds.

Lookups compute positions directly on the CPU ALU before a local L1 cache search, reducing memory by 99% and cutting latency by 3x.

To clarify the technical phrasing without buzzwords:

1. Baseline: BTreeMap is indeed mutable. PGM indexes target immutable / read-heavy sorted datasets (OLAP engines, columnar storage, and SSTables in LSM trees). Even compared to a flat slice::binary_search (~20 cache line jumps across an 8MB array for 1M keys), PGM drastically reduces memory traffic.
2. ALU computation: Once segment parameters are loaded, the index position is estimated with a single multiply-add instruction in CPU registers: pos = y0 + slope * (key - x0). No pointer chasing or node traversals.
3. L1 cache search: Because error is mathematically bounded to +/- epsilon (e.g. epsilon = 16), the target key is guaranteed to sit within a contiguous 256-byte slice (4 cache lines). The local search hits L1 cache with prefetching rather than jumping across RAM.

The implementation and release benchmarks are reproducible here: https://github.com/gilnett/learned_index_lab

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.

• GitHub: https://github.com/akawashiro/procinsh
• Blog: https://akawashiro.com/articles/procinsh-en

I have currently reached the stage where this can be considered to be near to finish. And I want help around now for how I can improve and use in real applications

https://github.com/crydafan/AndroidLibraryInjector

I decided to make this because I'm reverse engineering a banking application in order to audit their API and make an MCP out of it.

The application itself can detect when the Frida server is running and when the application was modified with Apktool (even the code is obfuscated) and nothing worked so this is my attempt at trying to hack it: inject a shared library into the application process to hook SSL libraries functions and inspect the HTTP requests in plain text before they are encrypted.

For this, the first moving part is the library injector. I was thinking of using Dobby to hook the functions. Anyways, I'm open for any feedback.

Thank you!

Hi r/embedded,

xuan (玄) is a lightweight JavaScript runtime for IoT and embedded devices, built on QuickJS and forked from tjs/txiki.js (MIT).

It targets the place where Node.js is too heavy: ~6–7 MB binary, low memory, ~5 ms cold start, and it cross-compiles to x86/ARM/MIPS/RISC-V. Built-in MQTT, serial port and FFI (call C libs directly); GPIO/I2C/SPI are in progress. You can also compile a script into a single self-contained binary with xuan compile.

Repo: https://github.com/topelinux/xuan

It's early but usable — feedback welcome. I'm the maintainer.

Hi everyone,

When debugging processes and inspecting system behavior on Windows, tools like Process Monitor (Procmon) are great, but they are heavy graphical utilities that rely on kernel-mode drivers. On the other hand, having a lightweight, terminal-native way to inspect system calls and Win32 APIs in real time was something I felt was missing for daily workflow.

I wanted to build an independent, lightweight alternative designed from scratch for the Windows console, with two strict requirements:

1. Pure terminal workflow (interactive TUI and scriptable stream).
2. Zero kernel drivers (pure userland Win32 and native OS ETW) to ensure safety and stability.

This is why I created wstrace, written entirely from scratch in Rust.

Core Features:

* Zero Kernel Drivers: Runs strictly in userland without third-party .sys drivers or ring-0 dependencies.

* Interactive TUI: Built with Ratatui, offering real-time process monitoring, event filtering, search, and activity timelines.

* Headless Stream Mode: Direct output to stdout (formatted text or JSON) for scripting, log analysis, and automation.

* Single Lightweight Binary: Fast startup, zero runtime dependencies, and minimal memory usage.

* 100% Local and Air-Gapped: Zero telemetry, zero analytics, and zero network calls.

Installation:

Prebuilt standalone binaries are available on GitHub Releases, and it can also be installed using Scoop, Winget, PowerShell, or Cargo:

cargo install --git https://github.com/gilnett/wstrace

Or via Scoop:

scoop install https://raw.githubusercontent.com/gilnett/wstrace/main/packaging/scoop/wstrace.json

Feedback & Feature Requests Welcome:

This is the initial v0.1.0 release. I would really appreciate any feedback, suggestions, or edge cases you encounter while testing it.

If there are specific Win32 APIs, events, or CLI flags you would like to see added, please let me know. I am actively maintaining the project and very open to community requests and contributions.

GitHub Repository: https://github.com/gilnett/wstrace

Thanks for checking it out!

Hey guys,

Wanted to share a tool I've been using in my own reversing workflow:

GitHub: https://github.com/oscarsantanaarias/IDA-Ghidra-bridge

I needed a straightforward way to pull decompilation, cross-references, and struct layouts out of IDA Pro and Ghidra from external Python scripts and CLI utilities without setting up heavy web servers or dealing with bloated RPC frameworks.

It’s just two standalone scripts (`ID_Server.py` for IDAPython and `Ghidra_Server.py` for Ghidra). Once running, you send plain text commands over local TCP and get back JSON:

```python

import socket, json

s = socket.socket()

s.connect(("127.0.0.1", 5073))

s.sendall(b"FUNC 00401000\n")

data = json.loads(s.recv(65536))

print(data["code"])

MIT Lectures of 6.1903 Introduction to Low-level Programming in C and Assembly...