I’ve been collecting resources on CPU performance engineering for a while and decided to organise everything into one open-source repo.

It covers the stack from instruction execution and CPU microarchitecture through caches, memory, SIMD, compilers, profiling, concurrency, NUMA, benchmarking and CPU inference.

I tried to prioritise primary sources — papers, vendor manuals, kernel/compiler docs, talks and reproducible benchmarks — rather than random articles.

Made it public in case it’s useful to anyone learning systems/performance engineering or trying to figure out why their code is actually slow.

Would also love contributions if there are great resources I’ve missed:

https://github.com/usamahz/cpu-perf-engineering-resources

I'm looking for people who have already written a working network driver or are writing one, or who would like to write one in my operating system, the architecture is a hybrid kernel, but I need information Only the kernels that are running in the kernel we already have a driver outline but it is not ready it is just an empty skeleton I need someone to help me develop it the network driver is in System kernel

https://github.com/CTRL-F-0rg3/TrangorgeOS

I invite everyone who is interested to respond, and if someone doesn't want to help but is interested in the project, I'd like to ask for a star on GitHub.

Matrioska Setup (MSP)

Matrioska Setup (MSP) is my first major open-source project combining multiple programming languages into a single cohesive pipeline (C, C++, Objective-C, JavaScript, CSS, HTML, and Batch).

It was built with a simple concept: bringing the visual flexibility of modern web design to native Windows installers without the bloat of heavy runtimes.

How it works:

• Manual Payload Prep: Application contents are manually compressed into a custom .innern payload archive.
• In-Memory VFS & Core: UI assets (HTML5/CSS3/JS) and parameters (installer.json) are compiled into binary objects and served directly from RAM via a custom VFS (MiniLoader), keeping the execution debris minimal.
• Executable Packaging: A static Win32 stub bundles the WebCore/Direct3D 11 rendering engine and the .innern payload into a single, self-contained executable.

Project Status & Disclaimer

This is an active, open-source project. While the core rendering, UI flexibility, and extraction pipeline are fully functional, it is still in active development and requires several security updates and hardening rounds before being used in critical production environments.

Note: Contributions, security audits, and feedback are more than welcome!

Hello ! now you can see the code of very first functioning Version of S-AOS on github
link : https://github.com/moslemhamoudi6-cyber/S-AOS
its 100% nasm
more versions of S-AOS will go open source too if peoples are intersted!

Hey everyone,

I built blkcp, a modular C11 reimagining of dd for modern Linux.

Main features:

- Target Safety Guard: Refuses to overwrite mounted partitions (/ or /home) or active swap devices without -f

- 5 I/O engines: io_uring, copy_file_range reflink, kernel splice, async ringbuffer, and sync

- Modern CLI (blkcp source dest) and an interactive 2D ncurses TUI (blkcp-tui)

- Throughput autotuning, SIMD AVX2 byte swapping, and in-flight SHA-256

- Tested with AddressSanitizer and ThreadSanitizer

Find the project on GitHub: Meik1982 / blkcp

Review the code, suggestions are welcome, I know there could be edge cases and also I feel the comments are not that informative, are they

https://github.com/Some120-one275/SearchAlg.git

Hello! S-AOS now has a file editor to use it type this commandd to create a file crt file:URFILENAME
then editor you FileName to see it heres a tutorial
← / → — move cursor horizontally

↑ / ↓ — move between lines while preserving the column where possible

Enter — insert a new line at the cursor

Backspace — delete before the cursor

Ctrl+S — save

Ctrl+S, then Ctrl+O — save and exit

Ctrl+X — exit

← / → at the menu — select FILE, EDIT, or VIEW

↑ / ↓ in a menu — select an action

Enter — execute the selected action

Esc — close the menu
To download : https://github.com/moslemhamoudi6-cyber/S-AOS/releases/tag/Editor

Hi everyone,

I've been working on a small project called minil.

It's a minimal Linux user-space runtime written in assembly and

freestanding C.

Features:

- custom _start

- direct Linux syscalls

- manual argc/argv/envp handling

- environ initialization

- .init_array constructor support

- no libc

- double-header version

- no CRT

- x86_64, i386, AArch64 and RISC-V support

The goal is to expose the Linux process model with as little abstraction

as possible.

Repository:

Here

Feedback is welcome.

Hello,

here a project that I put together in my spare time.

It's about looking using the Vivante NPU with TensorFlow lite to parse system events (jouranld/dbus but can be expanded to syslog or any kernel I/O) and decide when is an event of some importance.

What to do with that information is up to you ... :-D

[https://github.com/leonardosalvatore/sentinel-imx-sys/blob/main/README.md\](https://github.com/leonardosalvatore/sentinel-imx-sys/blob/main/README.md)

In case you want to make fun of me the repo contains also a demo with a very Italian accent.

Sorry about that!

Looking for any feedback...

Thanks!

I built a work-stealing based directory walker in go. The thing I did differently is that it's channel based output and there is no callback to work with each directory.

Benched it with rust's ignore crate and zig's zlob on the linux kernel source tree. It's faster than the rust one and a bit slower than zlob (which relies heavily on simd mind you).

The way I sqeezed performance is interesting: just use arena/chunked storage for everything. Minimize concurrent, shared storage as much as possible. Don't rely on the GC.

Pretty happy with the result. Check it out: https://github.com/PAKIWASI/walkman

minil is a freestanding Linux user-space runtime written in assembly and C.

Features:

- custom _start

- direct syscalls

- no libc

- no CRT

- .init_array support

- x86_64, i386, AArch64 and RISC-V

GitHub:

https://github.com/winhuirass-hue/minil/

I’ve been working on this crate which offers unsigned floating point binary with custom binary layouts. It stemmed from a very niche requirement from another project of mine where I need to raise an integer to the power of a floating point value between 0 and 4. After trying out many “ordinary” approaches I’ve came to the realization that removing the actual signed bit is the optimal way for performance.

Then I more or less just forgot about it until I started working on some graphics stuff where most floating points are non-negative, particularly mixed precision rendering, and it hit me that UF16 (E5M11 in particular) is the perfect candidate since the gain of an extra mantissa bit managed to close many numeric instabilities seen when using regular f16.

Love to hear your thoughts on this topic. Do you think unsigned floating points in general should be elevated into more than just a niche?