Lib.rs

nix

Rust friendly bindings to *nix APIs

signal-hook

Unix signal handling

rustix

Safe Rust bindings to POSIX/Unix/Linux/Winsock2-like syscalls

zbus

API for D-Bus communication

x11-dl

X11 library bindings for Rust

ndk-sys

FFI bindings for the Android NDK

users

Library for accessing Unix users and groups

caps

A pure-Rust library to work with Linux capabilities

x11

X11 library bindings for Rust

xcb

Rust safe bindings for XCB

syslog

Send log messages to syslog

if-addrs

Return interface IP addresses on Posix and windows systems

gdk-pixbuf

Rust bindings for the GdkPixbuf library

event-manager

Abstractions for implementing event based systems

procfs

Interface to the linux procfs pseudo-filesystem

x11rb

Rust bindings to X11

rlimit

Resource limits

bluer

BlueR: official Rust interface to the Linux Bluetooth protocol stack (BlueZ)

rustbus

An implementation of the dbus protocol

linux-loader

A Linux kernel image loading crate

bluez-async

An async wrapper around the D-Bus interface of BlueZ (the Linux Bluetooth daemon), supporting GATT client (central) functionality

seccompiler

Provides easy-to-use seccomp-bpf jailing

libsystemd

A pure-Rust client library to interact with systemd

calloop

A callback-based event loop

file-lock

File locking via POSIX advisory record locks

fuse-backend-rs

A rust library for Fuse(filesystem in userspace) servers and virtio-fs devices

selinux

Flexible Mandatory Access Control for Linux

automatic-timezoned

Automatically update system timezone based on location

shell-words

Process command line according to parsing rules of UNIX shell

ashpd

XDG portals wrapper in Rust using zbus

cgroups-rs

Native Rust crate for managing control groups on Linux

syscalls

A list of Linux system calls

dbus

Bindings to D-Bus, which is a bus commonly used on Linux for inter-process communication

libbpf-sys

Rust bindings to libbpf from the Linux kernel

termios

Safe bindings for the termios library

daemonize

Library to enable your code run as a daemon process on Unix-like systems

uds

A unix domain socket crate that supports abstract addresses, fd-passing and seqpacket sockets

rua

Secure jailed AUR helper for Arch Linux

gobject-sys

FFI bindings to libgobject-2.0

alpm

Rust bindings for libalpm

hyperlocal

Hyper bindings for Unix domain sockets

rexpect

Interact with unix processes/bash the same way as pexpect or Don libes expect does

sevctl

Administrative utility for AMD SEV

bpf-linker

BPF static linker

sysctl

Simplified interface to libc::sysctl

timeout-readwrite

Adds timeout capabilities to Readers and Writers

kqueue

kqueue interface for BSDs

sendfd

Send file descriptors along with data over UNIX domain sockets

zram-generator

Systemd unit generator for zram swap devices

drt-tools

Tools for Debian Release Team work

nixpkgs-fmt

Nix code formatter for nixpkgs

gpio-cdev

Linux GPIO Character Device Support (/dev/gpiochipN)

capctl

A pure-Rust interface to prctl() and Linux capabilities

tokio-seqpacket

unix seqpacket sockets for tokio

xremap

Dynamic key remapp for X and Wayland

sgx

Library for Intel SGX

memfd

A pure-Rust library to work with Linux memfd and sealing

devicemapper

A library for using Linux device mapper

font-manager

A simple utility to manage fonts on linux systems

devd-rs

An interface to devd, the device hotplug daemon on FreeBSD and DragonFlyBSD

ar

A library for encoding/decoding Unix archive files

oo7

James Bond went on a new mission and this time as a Secret Service provider

gpiocdev-cli

A tool to access GPIO lines on Linux using the GPIO character device

x11-clipboard

x11 clipboard support for Rust

linux-raw-sys

Generated bindings for Linux's userspace API

slog-term

Unix terminal drain and formatter for slog-rs

netlink-packet-core

netlink packet types

oxidebpf

A pure-Rust library for managing eBPF programs

timerfd

A rust interface to the Linux kernel's timerfd API

bpf-sys

Bindings for libbpf

listenfd

A simple library to work with listenfds passed from the outside (systemd/catflap socket activation)

tfc

The Fat Controller. A library for simulating mouse and keyboard events.

gtk-sys

FFI bindings to libgtk-3

spotifyd

A Spotify daemon

jobslot

An implementation of the GNU make jobserver for Rust

networkmanager

Bindings for the Linux NetworkManager

spotifyd/spotifyd

A Spotify daemon

umask

utility to deal with unix access mode

smithay-clipboard

Provides access to the wayland clipboard for client applications

libbpf-rs

libbpf-rs is a safe, idiomatic, and opinionated wrapper around libbpf-sys

kvm-bindings

Rust FFI bindings to KVM generated using bindgen

unixstring

An FFI-friendly null-terminated byte string

probes

Library to read out system stats from a machine running Unix

aya

An eBPF library with a focus on developer experience and operability

zincati

Update agent for Fedora CoreOS

logind-zbus

A dbus client (using zbus) for logind

freedesktop_entry_parser

A library for parsing FreeDesktop entry files

signal-hook-registry

Backend crate for signal-hook

mpris

Idiomatic MPRIS D-Bus interface library

daemonize-me

Rust library to ease the task of creating daemons on unix-like systems

fd-queue

A library to support fd passing on Unix sockets

drm

Safe, low-level bindings to the Direct Rendering Manager API

close_fds

A library that makes it easy to close all open file descriptors

fm-tui

A TUI file manager inspired by dired and ranger

xmas-elf

Library for parsing and navigating ELF data; zero-allocation, type-safe

elfloader

A rust library to load ELF files

zbus_polkit

PolicyKit binding

bluez-generated

Generated async D-Bus bindings for talking to BlueZ on Linux

flatpak-rs

Flatpak library for Rust

dnsclient

A small, simple and secure DNS client library

systemctl

Small crate to interact with systemd units

xkbcommon

Rust bindings and wrappers for libxkbcommon

linux-procfs

The linux-procfs is the data snap library for the /proc/ filesystem on the linux os

gdkx11

Rust bindings for the GDK X11 library

sudo_plugin

Macros to easily write custom sudo plugins

evdev

evdev interface for Linux

input-event-codes

Linux input event codes form linux/input_event_codes.h

pledge

Rust binding to OpenBSD's pledge(2) interface

rot8

automatic display rotation using built-in accelerometer

aur-depends

A libary for resolving aur dependencies

ocipkg

OCI registry for package distribution

libcryptsetup-rs

High level Rust bindings for libcryptsetup

sys-mount

High level FFI binding around the sys mount & umount2 calls

nydus-api

APIs for Nydus Image Service

exec

Use the POSIX exec function to replace the running program with another

pandora_box

Pandora's Box: A helper for SydBox, a seccomp-bpf based application sandbox, to make sandboxing practical

nftnl

Safe abstraction for libnftnl. Provides low-level userspace access to the in-kernel nf_tables subsystem

uapi

Wrappers for OS APIs on UNIX-like platform

libsystemd-sys

FFI bindings to libsystemd and libelogind

ecc608-linux

A library for accessing the ECC608 chip on Linux

circadian

Linux auto-suspend/wake power management daemon

refractor

Arch Linux Pacman Mirrors Management Tool

mprober-lib

A library aims to quickly collect Linux system information including hostname, kernel version, uptime, RTC time, load average, CPU, memory, network interfaces, block devices and processes

xdgkit

A command line kit for XDG specs. As well as a Rust library

xkb

Rusty wrapper around libxkbcommon

linux-futex

Futex: A Linux-specific fast user-space locking primitive

gag

Gag, redirect, or hold stdout/stderr output. Currently only *nix operating systems are supported.

jail_exporter

Prometheus exporter for FreeBSD jails

systeroid-core

Core library of systeroid

xsk-rs

Rust bindings for Linux AF_XDP sockets

limits-rs

Utilities for determining the limits that an operating system enforces on a given particular process

clone3

Rust bindings to the clone3 linux system call

sev

Library for AMD SEV

usb-disk-probe

Provides a stream type which can be used to probe for USB storage devices in the system

syscallz

Simple seccomp library for rust

unveil

Rust binding for OpenBSD's unveil(2)

epoll

Safe epoll interface

passfd

File descriptor passing

morganamilo/paru

Feature packed AUR helper

ipc-channel

A multiprocess drop-in replacement for Rust channels

rbpf

Virtual machine and JIT compiler for eBPF programs

unix_mode

Decode Unix file mode bits (even on non-Unix platforms)

nixmodule

Simple qemu wrapper to automatically test out-of-tree linux kernel modules across multiple kernel versions

gpiod

Linux GPIO character device interfacing

mmarinus

A safe mmap implementation

filedesc

thin wrapper around raw file descriptors

log4rs-syslog

Syslog appender for log4rs based on libc's syslog() function (*nix only)

alienware

API to control the lights on an Alienware Alpha R1/R2

simple-signal

Easy unix signals handler for Rust projects

ddc-enhanced-rs

DDC/CI high level library for Rust (cross platform)

systemd

A rust interface to libsystemd/libelogind provided APIs

cgroups-fs

Rust bindings to Linux Control Groups (cgroups)

rs-release

os-release parser

amdgpu-sysfs

Library for interacting with the Linux Kernel SysFS interface for GPUs (mainly targeted at the AMDGPU driver)

osmesa-sys

OSMesa library bindings for Rust

utmp-rs

Parsing utmp file

dl_api

The easiest, simplest and safest way to load dynamic (shared object) libraries from Rust!

hinoko

API bindings for hinoko library

kmod

Bindings to libkmod to manage linux kernel modules

gpiocdev

A library to access GPIO lines on Linux using the GPIO character device

breadx

Pure-Rust X11 connection implementation with a focus on adaptability

rline

Input line retrieval using libreadline's "Alternate Interface"

x11rb-protocol

Rust bindings to X11

sapp-linux

Part of miniquad rendering library. Orignally this was a sokol-app C code transpiled to rust with c2rust and partially rewritten to more idiomatic rust.

parity-tokio-ipc

Interprocess communication library for tokio

network-manager-connection-action

Execute commands on connections change using DBus network manager events

sudo

Detect if you are running as root, restart self with sudo if needed or setup uid zero when running with the SUID flag set

signal-hook-mio

MIO support for signal-hook

zbus_systemd

A pure-Rust library to interact with systemd DBus services

xcb-wm

Rust implementation of xcb-wm - icccm and ewmh extensions for xcb

monitord

monitord ... know how happy your systemd is! 😊

posixmq

An idiomatic library for using posix message queues, with optional mio integration

systemd-boot-friend-rs

Kernel version manager for systemd-boot

privdrop

A simple crate to drop privileges

udp_sas

Source address selection for UDP sockets

file-locker

File locking via POSIX advisory record locks

palaver

Cross-platform polyfills. This library attempts to provide reliable polyfills for functionality that isn't implemented on all platforms

filterm

Filter terminal data to and from a child process

clipboard_x11

A library to obtain access to the X11 clipboard

dma-heap

Linux DMA-Buf Heap Abstraction Library

ponde

Pointing device configurationd daemon for Wayland and X11 using libinput and uinput

wmctl

Rust X11 automation

command-fds

A library for passing arbitrary file descriptors when spawning child processes

pam-sys

FFI wrappers for the Linux Pluggable Authentication Modules (PAM)

controlgroup

Native Rust crate for cgroup operations

unix-exec-output-catcher

Library to run executables in a child process and catch STDOUT and STDERR output on UNIX-systems. std::process::Command is probably the better option. Use this source code as educational source how it could be done.

landlock

Landlock LSM helpers

mouse-keyboard-input

Send mouse and keyboard events on any distro and X11 or Wayland

whatsys

Determine the kernel version

etc-passwd

Get user information stored in the password file /etc/passwd

crate2nix

crate2nix generates nix (as in NixOS) build files for rust using cargo

shmemfdrs

Creates anonymous shared memory file descriptors for IPC on Unix platforms, using memfd/SHM_ANON/shm_open

frida-gum-sys

Rust generated bindings for Frida Gum

freebsd-libgeom

Rust bindings to FreeBSD's libgeom library

kvm-ioctls

Safe wrappers over KVM ioctls

systemd-rs

A high level systemd wrapper

libvibrant

A library to control screen saturation on X servers

xbgdump

CLI tool to dump the X11 background to a file

linux_modules

Tool To Manage Linux Kernel Modules

dbus-tokio

Makes it possible to use Tokio with D-Bus, which is a bus commonly used on Linux for inter-process communication

linux-libc-auxv

Linux passes an initial stack layout to applications, that contains argc, argv, envp, and the auxiliary vector right above the stack pointer. The libc of a Linux program parses this structure…

mnl

Safe abstraction for libmnl, a minimalistic user-space library oriented to Netlink developers

drm-fourcc

Provides an enum with every valid Direct Rendering Manager (DRM) format fourcc

systemd-run

A Rust crate for running processes as Systemd transient services

pamsm

Rust wrappers around PAM Service Modules functions

linux-kcapi

Tools for using crypto operation from the linux kernel

libblkid-rs

High level bindings for libblkid

mumblelink_reader

Mumblelink reader for Windows & Unix based operating systems

pea-p2p

Peacash P2P

hinawa

API bindings for hinawa library

rxscreen

A wrapper around libx11 to capture screenshots and save them

cbe_rbpf

Virtual machine and JIT compiler for eBPF programs

focus_monitor

Library for iterating over the focused window each time it changes

linux-errno

Linux error numbers

systemd_client

systemd client library implemented with zbus

sunshine-tray

A simple tray icon that shows the current status of sunshine as well as provided the ability to quickly start, stop or configure Sunshine

statx-sys

Bindings to statx syscall implemented by syscall

tokio-fd

Non-blocking Read and Write a Linux File Descriptor

rsbash

run bash commands from rust

memfile

memory backed files using memfd_create with file sealing support

vdso

Resolve Linux vDSO symbols

gdk-sys

FFI bindings to libgdk-3

font-loader

A font loading utility written in and for Rust

crossclip

Crossclip is a cross-platform Rust library for interfacing with the system clipboard

eos-eapi

Arista EOS eAPI client library

addy

POSIX interrupt handling that is both safe and ergonomic

spotify-launcher

Client for spotify's apt repository in Rust for Arch Linux

zwp-input-method-service

Safe wrapper to easily use the zwp-input-method protocol

libnss

Rust bindings for creating libnss modules

unix_socket2

Unix domain socket bindings, with bug fixes and enhancements

faf-syscall

Raw (asm), fast system calls for linux with no dependencies (no_std)

modinfo

Get modinfo section for Linux kernel module (.ko)

drm-ffi

Safe, low-level bindings to the Direct Rendering Manager API

cloudabi

Low level interface to CloudABI. Contains all syscalls and related types.

ioctl-rs

Rust bindings for system ioctls

nmdbus

Dbus bindings to the network manager

loopdev

Setup and control loop devices

gst-plugin-ximageredux

X11 Window Capture Engine

rushell

rushell is a POSIX compatible shell written by Rust language for Linux and MacOS

pino_xmodmap

a tiny xmodmap parsing library

containers-api-conn

Base connection interface used in podman-api and docker-api crates

deb-rust

Rust library for building and reading Deb packages

arch-mirrors-rs

Parse the Arch Linux mirror status

alsa-sys

FFI bindings for the ALSA project (Advanced Linux Sound Architecture)

liblmod

Library for loading Linux kernel modules

syswall_cli

syswall_cli: a simple CLI to syswall

redbpf-probes

eBPF probe-related types for redbpf

guzuta

Custom repository manager for ArchLinux pacman

cgroups

Native Rust crate for managing control groups on Linux

rustwide

Execute your code on the Rust ecosystem

xkeysym

A library for working with X11 keysyms

docker-sdk

docker-sdk for rust-lang

pathsearch

Search for files in PATH

kqueue-sys

Low-level kqueue interface for BSDs

sludge-ar-with-ranlib

A library for encoding/decoding Unix archive files

tokio-gpiod

Linux GPIO character device interfacing with tokio

file-owner

Set and get Unix file owner and group

sd-id128

A wrapper for sd-id128 implemented in libsystemd

hacksaw

Lightweight selection tool for usage in screenshot scripts etc

socketcan

Linux SocketCAN library. Send and receive CAN frames via CAN bus on Linux.

newt-sys

Low-level bindings for the Newt console UI library

lm-sensors

Hardware monitoring in Linux

tiny-nix-ipc

Minimal wrapper for using sockets as IPC with file descriptor passing

nixinfo

A lib crate for gathering system info such as cpu, distro, environment, kernel, etc in Rust

hyper-unix-connector

Use hyper with unix-domain sockets

bpfdeploy-libbpf-sys

Fork of libbpf-sys

zbus_xmlgen

D-Bus XML interface code generator

xproto

Rust bindings to the X11 protocol library

libmount

The type-safe wrapper around mount system call

display-info

Cross-platform get display info

nbd-netlink

Set up an NBD device for a specified socket and parameters, using the Linux netlink interface

queen-io

I/O library for Rust

transmission-gobject

gtk-rs gobject wrapper for transmission-client crate

subsystemctl

Utility to run systemd in WSL2 with a Linux namespace

neovim-ctrl

A program to find and interact with a Neovim instance running in a particular terminal

errno-dragonfly

Exposes errno functionality to stable Rust on DragonFlyBSD

monitord-exporter

monitord-exporter ... let prometheus know how happy your systemd is! 😊

alpmver

A simple crate to compare package Pacman package versions

daemonizr

Small crate which helps with writing daemon applications in Rust

apipe

An anonymous UNIX pipe type

pipe_watcher

A pipe reader and writer for the terminal. Made for use with the ipipe Rust library.

penguincrab

Rust wrapper for Linux Kernel as a Library

userfaultfd

Rust bindings for the Linux userfaultfd functionality

yeast

Yet Another Shell Trick

wmctrl

A wrapper for the command line tool wmctrl written in Rust

tide-trace

Minimum overhead USDT middleware to dynamically trace tide with BPF or DTrace

unix-named-pipe

Ease creation of named pipes on Unix platform

scheduler

Binding to set the linux scheduler (priority, policy, affinity, &c.)

paru

Feature packed AUR helper

jail

FreeBSD jail library

vfio-bindings

Rust FFI bindings to vfio generated using bindgen

xdpilone

Interaction with Linux XDP sockets and rings. No libbpf/libxpd-sys. Lightweight, high-performance.

rsprocmaps

A Rust library for handling memory maps in procfs

systemd-crontab-generator

Systemd generator for crontab files support

shiplift

A Rust interface for maneuvering Docker containers

async-signals

Library for easier and safe Unix signal handling with async Stream

whome

A command line program for detecting the current user’s name and environment. A rust replacement for whoami and hostname with added features.

libblkid-rs-sys

Low level bindings for libblkid

text-transliterate

simple utility for transliterate texts using the SO iconv from POSIX

clipboard-sync

Synchronizes the clipboard across multiple X11 and wayland instances running on the same machine

selinux-sys

Flexible Mandatory Access Control (MAC) for Linux

wepoll-ffi

Bindings for the wepoll library

mempeek

A command line tool that resembles a debugger as well as Cheat Engine, to search for values in memory

udsx

Some extensions for Unix domain sockets

eventfd

Binding to Linux's eventfd syscall

xdg-mime

A library for loading and querying the XDG shared MIME database

tokio-timerfd

timerfd support for tokio

rcore-os/linux-object

Linux kernel objects

sonde

A library to compile USDT probes into a Rust library

signal-hook-tokio

Tokio support for signal-hook

abpfiff

Interaction with Linux BPF(2). No libbpf-sys.

pdfork

fork wrapper that uses process descriptors (pdfork) on FreeBSD and normal fork elsewhere

libscmp

A safe, sane Rust interface to libseccomp on Linux

shells

Sugar-coating for invoking shell commands directly from Rust

nix-ptsname_r-shim

Nix ptsname_r shim

mmdbus

Dbus bindings to the ModemManager

openvpn3-rs

D-Bus bindings for OpenVPN3

journald

A rust binding for the systemd journald api

linux-support

Comprehensive Linux support for namespaces, cgroups, processes, scheduling, parsing /proc, parsing /sys, signals, hyper threads, CPUS, NUMA nodes, unusual file descriptors, PCI devices and much, much more

amy

Polling and Registration abstractions around kqueue and epoll for multithreaded async network programming

libxdo

Bindings to libxdo

sig

ffi library of signal(2) and kill(2)

pentacle

Executes programs as sealed anonymous files on Linux

pmc-rs

A safe abstraction for interacting with Performance Monitor Counters on FreeBSD

rustables

Safe abstraction for libnftnl. Provides low-level userspace access to the in-kernel nf_tables subsystem

sysfs-pwm

Provides access to the Linux sysfs interfaces to PWMs. Via this crate you can export, unexport, and control PWM pins for which there is an appropriate driver loaded in the kernel…

nftables-json

Serde JSON model for interacting with the nftables nft executable

libwmctl

Rust X11 automation

fiemap

call ioctl FIEMAP on files with ease

stdio-override

Rust library for overriding Stdin/Stdout/Stderr with a different File Descriptor

yad

Yet Another Daemonizer is a daemonizing crate to easily, simply, and correctly create legacy daemons

file-descriptors

Wrapper around the common kinds of (mostly Linux) file descriptors, including sockets, pipes, FIFOs, terminals, serial ports, character devices, epoll, POSIX message queues, timerfd…

alsaseq

API binding for alsaseq library

ioctl-sys

IO Control for POSIX-and-beyond systems (core fn & macros, see ioctls for many ioctl definitions)

my-test-app-bergwolf

A rust library for Fuse(filesystem in userspace) servers and virtio-fs devices

giit_rbpf

Virtual machine and JIT compiler for eBPF programs

posix-errno

POSIX error numbers

procstat

Parses the /proc/stat file into a struct

hydrogen

Multithreaded Linux TCP socket server using epoll

rxdp

Bindings for interoperating with XDP programs and eBPF maps

signal-child

A little library to easily signal other process with no dependencies

dma-buf

Linux DMA-Buf Abstraction Library

nftnl-sys

Low level FFI bindings to libnftnl. Provides low-level userspace access to the in-kernel nf_tables subsystem

processmon

Process monitor that can run trigger scripts and subsequently restarts the process when files on specified paths are modified

linux-syscall

Linux syscall macros

linicon

Look up icons and icon theme info on Linux

af_packet

AF_PACKET bindings for Rust, primarily to be used for high-performance network security applications

tokio-linux-aio

Tokio bindings for Linux kernel AIO

rustop-rs

Linux system information parser

frida-sys

Rust generated bindings for Frida

extrasafe

Make your code extrasafe by preventing it from calling unneeded syscalls

nydus-rafs

The RAFS filesystem format for Nydus Image Service

zbus_names

A collection of D-Bus bus names types

librelic

Package management library for Arch Linux

pea-amount

エンドウ

acl-sys

FFI interface for POSIX Access Control Lists

signal

The higher-level abstractions around unix signals

raw_sync

Lightweight wrapper around OS synchronization primitives

raw-syscall-base

Low-level raw system call base

unixbar

cntr-nix

Rust friendly bindings to *nix APIs (fork with features used in cntr)

systemd-zbus

A dbus client (using zbus) for systemd

dbus-crossroads

Framework for writing D-Bus method handlers

kmod-sys

Bindings to libkmod to manage linux kernel modules

ioctls

IO Control for POSIX-and-beyond systems (numerous ioctl specifications, see ioctl-sys for core functions & macros)

tokio-unix-ipc

A minimal abstraction for IPC via unix sockets

upower_dbus

UPower info via zbus

proc-mounts

Fetch active mounts and swaps on a Linux system

glib_rs

Reserved, to avoid name confusion with https://github.com/glib-rs/glib_rs, a potential replacement of (parts of) glibc on Linux

alpm-ll

Rust bindings for libalpm

gdk-pixbuf-sys

FFI bindings to libgdk_pixbuf-2.0

linux_proc

A library to help reading the contents of /proc on linux

soup3

Soup crate for Rust

illumos-priv

Crate providing an interface to illumos's PRIVILEGES(5)

libvibrant-ffi

C bindings for libvibrant, a library to control screen saturation on X servers

utmp-raw

Provides raw types for parsing login records in utmp file

linapi

High level bindings to various Linux APIs and interfaces

gpiosim

A library to drive gpio-sims for GPIO software testing

pino_xrdb

Simple xrdb query library

spirit-daemonize

Spirit helpers and config fragments to daemonize

async-std-gpiod

Linux GPIO character device interfacing with async-std

bpfjit-sys

Rust bindings to NetBSD's cBPF JIT engine

aura-pm

Install and manage Arch Linux packages

async-std-hidg

Linux USB HID Gadget emulation for async-std runtime

userfaultfd-sys

Low-level bindings for userfaultfd functionality on Linux

dux

X11 backlight manager

bpf-rs

A safe, lean library for inspecting and querying eBPF objects

hidraw-sys

Linux hidraw definitions from linux/hidraw.h

xkbcommon-sys

Bindings to libxkbcommon

updlockfiles

Manage lockfiles in PKGBUILDs for upstreams that don’t ship them, updpkgsums for dependency trees (Arch Linux tooling)

freebsd-libgeom-sys

Rust FFI bindings to FreeBSD's libgeom library

polkit

High-level bindings for libpolkit-gobject-1

proc-status

simple access to proc/status info on unix

rctl

FreeBSD resource limits and accounting with RCTL / RACCT

stemjail

Evolving jails for user activities

spice-client-glib

Rust bindings for the Spice client library

daemonize-simple

A simple crate to run an app as a Unix daemon

mnl-sys

Low level FFI bindings to libmnl. A minimalistic user-space library oriented to Netlink developers

syscall-numbers

System calls numbers for various architectures

sensors-sys

Hardware monitoring in Linux