linux-raw-sys

This is the foundation layer underneath `rustix` - raw, auto-generated bindings to Linux syscalls with zero abstraction. In production systems where you need direct syscall access without libc overhead, it delivers. The bindings are comprehensive and stay current with kernel versions. Memory footprint is minimal since it's just type definitions and constants.

The challenge is that you're working at the absolute lowest level. No error handling, no type safety beyond what the kernel provides, no retry logic - you get raw syscall numbers and structs. This means you handle EINTR yourself, manage all resource cleanup manually, and deal with architecture-specific quirks. Documentation is essentially nonexistent because these are generated bindings; you need to reference kernel docs directly.

For most production work, you want `rustix` or `nix` on top of this. Use `linux-raw-sys` directly only when building your own syscall wrappers or when you need bleeding-edge kernel features not yet wrapped by higher-level crates. Updates can introduce breaking changes as kernel APIs evolve, requiring careful version pinning in stable systems.

linux-raw-sys provides auto-generated Rust bindings directly to Linux syscalls and kernel structures. This is as close to the metal as you can get without writing assembly. The bindings are accurate and comprehensive, covering the full Linux API surface, but using them feels like programming in C with Rust syntax.

The DX is intentionally minimal—there's virtually no documentation beyond what's auto-generated from kernel headers. You'll need to reference Linux man pages constantly and understand the exact semantics of raw syscalls. Type safety is limited to what the kernel API provides, meaning lots of raw pointers, integer flags, and undefined behavior if you get things wrong. Error handling is entirely manual via checking return codes.

For most projects, you should reach for higher-level abstractions like rustix or nix instead. This crate is really a building block for those libraries rather than something you'd use directly. The ergonomics are poor by design—it's meant to be a thin, zero-cost binding layer that other crates build upon.

This package provides raw, auto-generated bindings to Linux system calls and structures. It's intentionally minimal - you get direct access to kernel interfaces without any safety wrappers or abstractions. The learning curve is steep because you need deep knowledge of Linux kernel APIs, not just Rust. Error messages are essentially non-existent since these are raw FFI bindings, and when things go wrong, you're debugging at the syscall level.

There's virtually no documentation beyond what's auto-generated from kernel headers. You'll find yourself constantly cross-referencing man pages and kernel documentation to understand what each constant or structure does. The package serves its purpose as a foundation layer, but it's not designed for direct use by most developers. Common use cases aren't straightforward because there are no examples - this is by design, as it's meant to be consumed by higher-level libraries like rustix.

If you're building low-level system utilities or need specific Linux features not yet exposed by safe wrappers, this does the job. But expect to invest significant time understanding both the kernel APIs and how to use them safely from Rust.