r/lowlevel

Warning: This project was built using AI, mostly with free plans, but also with the support of Claude Code. It's not the nature of my post to pretend I created anything here; I was really just the supervisor. That said, the huge nature (at least from my point of view) of this project, and my limited financial resources have forced me to constantly think and learn, and continue to do so, so I consider myself at a lower level in terms of coding skills than most of the people who are part of this community, and I love seeing how each of us makes mistakes and tries to patch them.

Nexsos is therefore a project born to allow me to learn in an interactive and gradual way what all the aspects of a computer are, and to allow me to do so in an informal way, and with gradual discovery. Nexsos is not intended to be a product or a boast, it is in all respects a Frankenstein born to test how much human ignorance and curiosity mixed with the algorithmic knowledge of an LLM can give life to something that works.

On the technical side, the purpose of NexsOS1 is simple: to separate the kernel from the userspace to allow me to learn the C language on my API without blowing everyone up, and at the same time to make my C library simple and readable in a single file. The graphics protocol had to be designed in the same way. The easy choices would have been two: to provide a basic environment for GNU Utilis and compile an X server/Wayland, or to rewrite the graphical interface from scratch. I stupidly chose the second one and with all the problems that come with it, for example, for now the compositor is in the kernel and shadows without hardware vector accelerators make the framerate explode. The good thing, however, is that the rendering of the applications is done in userland, so having SMP support makes graphical applications easier.

That said, why this video? At some point in our journey, we should ask ourselves how useful we really are to others. I have always seen AI as a very powerful tool, but perhaps we tend to forget what it means for us, I do not have the actual skills to build a functional and working system on two architectures with multitasking and a working SMP, but if I do not have the actual skills to do this and I can do it, what can these tools do in the hands of large companies that do not want to share the code? Even if I call myself ignorant, perhaps I am ignorant about coding, here we all know how the GNU project and the GPL project were born, I do not know what the members of this thread think about it and I do not even know if it is the right thread, after all, guys, we also know how these LLMs were trained on the effort of all software developers, is it right to privatize public knowledge? As far as I am concerned, the only thing I could really do is exploit the knowledge of AI itself to put together and build something free, so I do not know how you want to define NexsOS, I do not care, the important thing for me is that it is free and that anyone can in turn steal code from within it.

NOTE: If anyone would like to look at the code and has any questions about missing references or licenses, I'd be happy to update the published code. Any criticism is welcome.

NOTE2: lua still doesn't pass all the tests, even though the IDE works and also the job controls of my shell seem ok (I didn't show them in this video), the exec daemon is ok, but I'm having problems with the initialization of the venv for pid.

NexsOS1

Learning project that became my favourite: a chiptune synth written entirely in x86-64 assembly (Linux, NASM). No libc, no audio library — just computing raw 16-bit samples and writing a WAV header by hand.

The premise is that sound is just a list of numbers (44100/second) describing where a speaker sits. So the whole synth is: generate the numbers, write them out.

It does four oscillators (square/saw/triangle + LFSR noise), polyphony by mixing voices into one buffer, ADSR envelopes, and FM synthesis with a hand-built sine table. Working on effects next (vibrato, delay, reverb).

github.com/whispem/asm.fm

Feedback on the low-level details welcome — especially the fixed-point math in the FM operator.

my u-boot fork

my linux fork

my qemu fork

I am developing my own operating system which aims to meet my own needs and those of others in terms of energy consumption, modularity and the system itself being based on a hybrid system kernel. Cell system is the creation of a modular system with three driver divisions with well-balanced compatibility layers on its own architecture without relying on standard unix-like

At the same time, we are looking for people to support the free project to develop it. The project is young, limited at times, typically demonstrative, but the most important thing is the cell and we are developing it to develop it. 3 people on the unstable branch and we are looking for support in the development of various system components such as the kernel network driver or the file system The system is open to various languages, although it is mainly Rust, but we also use C, Hal, Ada, Spark, Zig and other languages for development. It is important for us to match the language to the given task.

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

If you've ever tried to figure out what is eating up your Android's storage before doing a massive data dump, you know the pain. Trying to view a /DCIM folder with 10,000+ files over a standard USB cable usually makes Windows Explorer or macOS Finder infinitely load, freeze, or crash because MTP is fundamentally broken for high file counts.

I got tired of waiting 4+ minutes just to see my folder sizes, so I built an open-source analyzer called SocketSweep that bypasses MTP entirely.

How it works (The Architecture): Instead of using standard USB bulk transfers to read the filesystem, it uses a multi-language stack to pull the file tree at bare-metal speeds:

• The Engine: It pushes a native C++17 daemon to /data/local/tmp via ADB. Because it runs under the shell context, it executes POSIX filesystem traversals natively on the device. (Zero root required).
• The Bridge: It pipes the raw JSON tree data back to your PC over a local TCP socket tunnel, bridged via adb forward.
• The UI: A Rust/Tauri desktop app consumes the TCP stream concurrently and maps your entire storage into an interactive React Treemap.

The result: You can visually hunt down your biggest folders and delete the junk instantly. A 4-minute MTP "Loading..." hang becomes a 1.2-second instant scan.

Right now, the first release is compiled for macOS (Windows/Linux builds via GitHub actions are next, but you can build from source). It is GPL-3.0.

• GitHub Repository: https://github.com/VishnuSrivatsava/SocketSweep
• Download macOS .dmg: https://github.com/VishnuSrivatsava/SocketSweep/releases/tag/v1.0.0

(Note: For Android 11+, the app automatically uses an appops ADB command to grant itself Scoped Storage bypass permissions so it can read your full /sdcard without issues).

Let me know what you guys think of the architecture!

Hey Devs,

I’m building an enterprise style fully customizable OS. It’ll be native to any platform and mobile forward.
Check out the GitHub - https://github.com/jmw7629/JOEOS
Http - https://mcso9tqzb9.tailb9395f.ts.net/

The JoeOS Object System.

Every operating system has a fundamental abstraction:

Windows → Objects and Handles.
macOS → NSObject / Core Foundation.
Linux → Files, processes, descriptors.

JoeOS will have Enterprise Objects. Everything is an object. The OS doesn’t care whether it’s a window, an employee record, a workflow, or a machine—it all follows the same lifecycle and APIs.

This is in development - all comments suggestions or dev is encouraged and welcome, even if it’s critical. If you do pull the repo I only ask that you share your work path to collab.

More to come soon.
Thanks Fellas
//JWillyStyle

Github Repo

Hey everyone,

I wanted to share a project I've been building: HexaCore, a lightweight memory scanner and tool built from scratch using C++ and the Win32 API.

Key Features:

• Multi-level pointer chain resolver & scanner
• Array of Bytes (AOB) scanning with wildcard support
• Built-in Hex Viewer, basic Disassembler, and NOP/Patch tool
• Custom dark UI with card-based panels and adjustable freezing intervals
• Cheat table save/load system

It's open-source. I'd love to hear your feedback or suggestions for the V1 version!

GitHub / Source Code: https://github.com/abuzit/HexaCore-Memory-Tool

AVX-512 support in my own Assembler

About a year ago I started writing AmmAsm, a handwritten x86-64 assembler in C to better understand x86-64 instruction encoding, ELF, and linking.

It currently supports generating Linux x86-64 executables, PIE binaries, and ELF relocatable object files that can be linked with ld or gcc, basic part of SIMD such as sse, sse2, avx, avx2, avx512

I implemented everything from the lexer and parser to the instruction encoder, ELF writer, relocation handling, symbol resolution.

In last realize, I fully implemented VEX/EVEX, including vvvv, w, mmm, broadcast, k0/k1-k7 mask registers, z mask, tuple type, and other fields thats belong to vex and evex. The most hard part was a W and tuple time, as I spend hours for searching every avx512 instruction for type of tuple if broadcast exists and W field.

I'd love to hear feedback from people interested in assemblers, instruction encoding(especially VEX/EVEX), or x86-64 in general.

Thanks!

Repository: https://github.com/LinuxCoder13/AmmAsm

D.eSystem 6.1.0 introduces a small setup and you can choose your UI with D.eSystem 6.1.0.

D.eSystem 6.1.0 on github: https://github.com/D-electronics-scratch/all_D.eSystem_versions/releases/tag/v.6.1.0

All current D.eSystem releases on github: https://github.com/D-electronics-scratch/all_D.eSystem_versions/tags

As the title says I've been working on a serialization format i plant to use for many future projects, sadly I've been so focused on the document i dont really have sat down to write the parser, but I'd love to get feedback and see if im not going entirely crazy! There may be things and possible interactions still missing.

Anyways, here is the link: https://gist.github.com/ErrorDAR32/130f03e3eed484dcc703e5e30e27614f

Edit: Typo