Filter
Exclude
Time range
-
Near
0x_codex
The most interesting part of crustc is not the meme version, “rewrite Rust in C.” It is the systems version: C is being used as a portability rail for Rust, not as the language humans are supposed to go back to writing. The demo is intentionally absurd in the best way: rustc 1.98 nightly, converted into roughly 46 million lines of C, then built with GCC and make into a working Rust compiler. The project still depends on the right LLVM libraries and the author is explicit that the full cilly toolchain is not ready for general use. But the shape of the idea matters more than the stunt. Rust’s portability story normally routes through a fairly modern compiler stack. If your target has good LLVM support, life is much easier. If the platform is old, obscure, embedded, or just weird enough that it has a C compiler but no realistic Rust path, the language can become stranded behind its backend. cilly attacks that boundary from the other side. Instead of assuming a neat platform model, it emits witness programs and asks the target compiler what reality looks like: thread-local support, layout, size, alignment, character encoding, integer format, ABI behavior. The output is not one magical portable C blob you can throw at every architecture. It is target-specific C generated for the compiler and platform in front of it. That distinction is the whole lesson. Portability is not “write once, assume everywhere.” Portability is a negotiation layer. You measure the host, adapt the artifact, and keep the higher-level source language intact. The network bridge idea is especially revealing: run rustc on a normal machine, talk over the wire to a tiny C compiler server on the odd target, and let the target’s own toolchain participate in the build. That turns C from a nostalgic fallback into an interoperability protocol between language ecosystems and hardware history. The obvious caveat is trust. A rough Rust-to-C path is not something you casually insert into production just because it compiles. But as a research direction, it points at a bigger theme for compilers, agents, and infrastructure: the valuable layer is often not the most elegant language or the most powerful backend. It is the adapter that preserves intent across hostile boundaries. crustc is funny because the direction looks backwards. It is important because sometimes the “backwards” layer is the only bridge that still reaches the machine. #Rust #Compilers #DevTools #OpenSource #SystemsProgramming
72
Just_OSdever
Working on a custom memory allocator aiming for near-zero fragmentation. 👑️ More updates coming soon. If you're interested, drop a comment! 🔥 #OSDev #SystemsProgramming #MemoryManagement #BuildInPublic #BarqOS
1
15
Just_OSdever
Designing a custom memory allocator focused on minimizing fragmentation while keeping allocations fast. ⚡️ If this kind of low-level programming interests you, let me know in the comments. 👇️ #OSDev #SystemsProgramming #MemoryManagement #BuildInPublic #BarqOS
1
22
Just_OSdever
Currently developing a custom memory allocator with a strong focus on fragmentation reduction, allocation speed, and memory efficiency. 🔪️ Looking forward to sharing the results soon. 🔥️ #OSDev #SystemsProgramming #MemoryManagement #BuildInPublic #BarqOS
1
14
Just_OSdever
What if memory fragmentation wasn't a problem anymore? 🔪️ I'm working on something that gets surprisingly close. 🔥️ More details soon. ⏲️ #OSDev #SystemsProgramming #MemoryManagement #BuildInPublic #BarqOS
1
8
ayushagarwal027
The Qt Company just released official Rust bindings for Qt. 🦀 qtbridge-rust lets you write Qt Quick (QML) UIs with a pure Rust backend, no C required. What this means: → QObject, signals, slots, and properties via Rust attribute macros → Built on CXX : safe Rust/C interop under the hood → Tokio integration : async Rust works natively → Released directly from the qt org on GitHub Qt runs everywhere : embedded, automotive, industrial, desktop. That entire ecosystem is now accessible from pure Rust without touching C . 🔗 github.com/qt/qtbridge-rust #Rust #RustLang #Qt #GUI #Embedded #OpenSource #Automotive #SystemsProgramming
3
16
179
9,624
Apress
Understand what really happens when your code runs. Author @chessMan786 helps you dive into #ELF binaries to learn how programs are compiled, linked, and executed in #Linux systems—and why it matters for performance and security. #SystemsProgramming 🔗 ow.ly/4suv50Z0oj2
11
5,524
chenzeling4
AI coding agents just wrote a production-grade static linker. Red, the language descended from Rebol, shipped static linking for C libraries this week. Add one flag (-s) and your dependencies bake into a single executable under 50KB. The linker parses COFF, ELF, and Mach-O. It does COMDAT folding, selective archive loading, full relocation support including ARM Thumb-2 split immediates for the Raspberry Pi. Cross-compilation works too. Nenad Rakocevic, Red's creator, built it with heavy assistance from Claude Code and Codex. Then he used the same agents to build CherryTracker, a full soundtracker MOD player, as a demo. In his spare time. Over a few weeks. People keep saying AI agents can do CRUD but choke on systems programming. Linkers are about as fiddly as it gets. Format-specific, unforgiving, full of edge cases around relocations and symbol resolution. If agents can assist here, that boundary keeps moving. #Programming #AI #SystemsProgramming red-lang.org/2026/06/static-…
1
70
ranu_patha91877
VecLite uses two independent RwLocks — one for storage, one for the index — instead of one global lock. Reads stay concurrent, writes acquire storage before index to avoid deadlock. github.com/mayanpathak/vecli… #rustlang #systemsprogramming
31
ranu_patha91877
No Postgres. No SQLite. No FAISS. Just Rust. Built my own vector DB with IVF K-means clustering and a gRPC API from scratch. github.com/mayanpathak/vecli… #rustlang #systemsprogramming
1
23
RyanWill98382
Zero copies. Zero parsing overhead. Just pure, unadulterated throughput. 🏎️💨 Taking low-level data paths to the limit. Check out the latest updates to the repository: 👉github.com/rwilliamspbg-ops #AF_XDP #LinuxKernel #SystemsProgramming #NetworkEngineering #Performance
1
17
0x_codex
A CUDA kernel launch looks like a single line of code, but it behaves more like a distributed control-plane protocol. Fergus Finn’s new deep dive follows the smallest possible demo — a vector add, `vadd<<<4096,256>>>`, one thread per float — and the surprising part is not the math. The math is just 1 1, repeated 1,048,576 times. The interesting part is how much machinery has to agree before any of those additions can happen. First, the kernel is not simply “compiled.” `nvcc` acts as a driver over multiple compilers: device code becomes PTX, PTX becomes architecture-specific SASS, and the executable carries a fatbin that can include both cubin and PTX. Then the host runtime and driver turn the launch into structured device state: arguments, launch geometry, constant-bank values, QMD-like metadata, command buffers, ioctls, and eventually a memory-mapped doorbell that tells the GPU there is work to pull. Only after that does the mental model most people have — blocks landing on SMs, warps issuing load/add/store instructions, memory moving through the hierarchy — become the center of the story. Even then, the CPU is not “running the GPU.” It is enqueueing work, syncing at the boundary, and reading back a result once the device-side machine has made progress. This is why GPU programming feels simple at the surface and weird at the edges. The source syntax sells you a function call. The real system is a contract between compiler artifacts, driver state, queues, schedulers, memory ordering, and synchronization. Performance bugs, startup latency, portability issues, and observability gaps often live in those seams, not in the arithmetic line inside the kernel. The broader AI-infra lesson is the same one we keep rediscovering with agents, databases, browsers, and cloud runtimes: the “smart” part is rarely just the compute core. The durable advantage is the control plane around it — the layer that packages intent, routes work, preserves compatibility, exposes state, and makes failure legible. If you want to understand modern AI systems, do not only look at FLOPS. Look at the launch path. #CUDA #GPU #AIInfrastructure #SystemsProgramming #DevTools
53
Apress
Understand what really happens when your code runs. Author @chessMan786 helps you dive into #ELF binaries to learn how programs are compiled, linked, and executed in #Linux systems—and why it matters for performance and security. #SystemsProgramming 🔗 ow.ly/4suv50Z0oj2
158
Emma_ifedi
represent a text document while it is edited in a text editor, this is the structure used by @code en.wikipedia.org/wiki/Piece_… #systemsprogramming #lowlevel
1
1
475
YourFutureCoder
Most software stacks brute-force spatial reconstruction using O(n^2) iterative physics constraint solvers or massive, compute-heavy local neural network weights. This runtime engine handles 100,000 points entirely in-memory with a single closed-form geometric operation. Here is a 100K-point torus knot swarm undergoing mathematical shattering and perfect autonomous recovery via the C 20 HDC/CGA5D runtime. Phase 1: Macro-geometry compressed into a single 1024-dim Hyperdimensional Computing (HDC) vector stored in local episodic memory. Phase 2: Deterministic chaos injection. The engine detects the thermodynamic decoherence instantly via continuous raw coordinate entropy profiling (not normalized vector variance).  Phase 3: Bounded routing deduces the exact geometric gap between the shattered state and the baseline, generating a single Conformal Geometric Algebra (CGA5D) motor to herd the points back on the most energy-efficient path. Zero cloud dependencies. Zero vector databases. Pure L1/L2 cache-resident C 20 execution. #Cpp #GeometricAlgebra #HyperdimensionalComputing #SystemsProgramming #PhysicsEngines
What if your software could remember without a database? A new sub-megabyte zero-dependency C 20 engine is coming. It gives applications lightweight episodic memory, working recall, entropy profiling, and bounded candidate routing without Python, without a vector database, and without cloud infrastructure. Not another chatbot wrapper. Not another bloated AI framework. A native memory-and-routing core for adaptive software. Built for embedded AI, simulations, stream intelligence, and local agent systems. A program that lets software stop merely reacting and start carrying state. Coming soon.
1
175
ayushagarwal027
Great writeup on rewriting a C web crawler in async Rust. 🦀 The author had a working synchronous C crawler : blocking, recursive, simple. Rewriting it in Rust became a deep dive into async fundamentals. Concepts covered: → Actor model : crawler, view, and connector as decoupled message-passing actors → tokio::spawn for concurrent page fetching → spawn_blocking for CPU-heavy HTML parsing → Bounded channels for backpressure → try_recv() to keep the GUI responsive without blocking The result: a live graph that expands as pages are discovered, with node details, broken link tracking, and dynamic crawl requests. A practical, well-explained journey from sync C to idiomatic async Rust. 🔗 raydroplet.dev/log/crawler #Rust #RustLang #AsyncRust #Tokio #OpenSource #SystemsProgramming #LearnRust
8
44
2,305