Lib.rs

nix

Rust friendly bindings to *nix APIs

dbus

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

users

Library for accessing Unix users and groups

notify-rust

Show desktop notifications (linux, bsd, mac). Pure Rust dbus client and server.

rua

Secure jailed AUR helper for Arch Linux

signal-hook

Unix signal handling

procfs

Interface to the linux procfs pseudo-filesystem

calloop

A callback-based event loop

redbpf

eBPF build and runtime library

daemonize

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

rtnetlink

manipulate linux networking resources via netlink

caps

A pure-Rust library to work with Linux capabilities

neli

Type safe netlink library written in Rust

xdg

A library for storing and retrieving files according to XDG Base Directory specification

gpio-cdev

Linux GPIO Character Device Support (/dev/gpiochipN)

shell-words

Process command line according to parsing rules of UNIX shell

epoll

Safe epoll interface

umask

utility to deal with unix access mode

copyless

Ways to eliminate memcpy calls when using the standard library

redbpf-probes

eBPF probe-related types for redbpf

rexpect

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

linux-loader

A Linux kernel image loading crate

rlimit

A simple wrapper for getrlimit and setrlimit

ar

A library for encoding/decoding Unix archive files

dbus-codegen

Binary crate to generate Rust code from XML introspection data

partition-identity

Find the ID of a device by its path, or find a device path by its ID

shh

Silence stderr and stdout, optionally rerouting it

event-manager

Abstractions for implementing event based systems

simple-signal

Easy unix signals handler for Rust projects

libbpf-sys

Rust bindings to libbpf from the Linux kernel

log4rs-syslog

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

systemd

A rust interface to libsystemd/libelogind provided APIs

alsa-sys

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

zbus_polkit

PolicyKit binding

sysctl

Simplified interface to libc::sysctl

timeout-readwrite

Adds timeout capabilities to Readers and Writers

nftnl

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

libmount

The type-safe wrapper around mount system call

system-call

Raw system calls

pico-args

An ultra simple CLI arguments parser

proc-mounts

Fetch active mounts and swaps on a Linux system

arch-audit

A utility like pkg-audit for Arch Linux based on Arch Security Team data

linux_modules

Tool To Manage Linux Kernel Modules

libnss

Rust bindings for creating libnss modules

libsystemd

A pure-Rust client library to interact with systemd

bpf-sys

Bindings for libbpf from BCC

libudev-sys

FFI bindings to libudev

signal-hook-registry

Backend crate for signal-hook

libgssapi

A safe binding to gssapi

af_packet

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

controlgroup

Native Rust crate for cgroup operations

dl_api

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

netlink-sys

netlink sockets, with optional integration with mio and tokio

sc

Raw system calls

posix-acl

Simple library to interact with POSIX filesystem ACLs

evcxr_jupyter

An Jupyter Kernel for Rust

syswall_cli

syswall_cli: a simple CLI to syswall

sharexin

ShareX for Linux and BSD

neovim-ctrl

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

jail

FreeBSD jail library

syscalls

A list of Linux system calls

rbpf

Virtual machine and JIT compiler for eBPF programs

close_fds

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

sendfd

Send file descriptors along with data over UNIX domain sockets

x11rb

Rust bindings to X11

ipmpsc

Inter-process Multiple Producer, Single Consumer Channels

privdrop

A simple crate to drop privileges

addy

POSIX interrupt handling that is both safe and ergonomic

kqueue

kqueue interface for BSDs

input-linux-sys

Bindings for <linux/{u,}input.h>

cgroups-fs

Rust bindings to Linux Control Groups (cgroups)

freedesktop_entry_parser

A library for parsing FreeDesktop entry files

cntr-nix

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

autopilot

A simple, cross-platform GUI automation library for Rust

mpris-player

A library for creating MPRIS2 media players over D-Bus

xmas-elf

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

fd-queue

A library to support fd passing on Unix sockets

mpris

Idiomatic MPRIS D-Bus interface library

shiplift

A Rust interface for maneuvering Docker containers

devd-rs

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

memfd

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

readable-perms

More usable UNIX file permissions interface

sudo_plugin

Macros to easily write custom sudo plugins

rustop-rs

Linux system information parser

uname

Name and information about current kernel

sys-mount

High level FFI binding around the sys mount & umount2 calls

unix_exec_piper

unix_exec_piper helps you to exec multiple commands where STDOUT of one process is connected to STDIN of the next process. This is what a shell (like bash) does internally.

lines_from_request

Read lines from a hyper Body in a blocking manner

pam-sys

FFI wrappers for the Linux Pluggable Authentication Modules (PAM)

yogawm

The flexible library for creating x window managers

screenruster-saver-laughing_man

Ghost in the Shell inspired screen saver for ScreenRuster

vtcol

Set Linux console color scheme

uhid-virt

Interface to Linux UHID (user-space HID transport drivers)

networkmanager

Bindings for the Linux NetworkManager

uapi

Wrappers for OS APIs on UNIX-like platform

rline

Input line retrieval using libreadline’s “Alternate Interface”

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

async-pidfd

Process file descriptors (pidfd) for Linux

libiio-sys

Native, unsafe, bindings to the Linux libiio library. Used by industrial-io.

libdbus-sys

FFI bindings to libdbus

wmctrl

A wrapper for the command line tool wmctrl written in Rust

procps-sys

Interface with procps library on Linux

vfio-bindings

Rust FFI bindings to vfio generated using bindgen

devicemapper

A library for using Linux device mapper

glx

GLX 1.4 bindings for Linux

cfile

Rust bindings to C *FILE stream

pamsm

Rust wrappers around PAM Service Modules functions

palaver

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

seccomp-sys

low-level bindings to libseccomp

prctl

This package provides safe abstraction to the linux prctl() interface. Some functions may be architecture-specific.

posish

Safe Rust bindings to POSIX-ish libc APIs

alpm-sys-fork

Raw bindings for libalpm

rebpf

A ebpf library built on top of libbpf (no bcc dependency)

metagoblin

Generates metadata for a binary format using goblin

xdg-utils

Query system for default apps using XDG MIME databases. Rust implementations of some common functions in the freedesktop project xdg-utils.

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…

osmesa-sys

OSMesa library bindings for Rust

uds

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

vm-info

Inspect Linux virtual memory structure

gudev-sys

Rust ffi interface for gudev, the glib support library for libudev

daemonize-me

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

linux-stats

typesafe procfs info

gag

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

socket-priority

Set a priority on a raw socket

coreutils_core

A crate with abstractions to implement UNIX core utilities

zbus

API for D-Bus communication

alpm-utils

Helper functions for working with alpm

redbpf-macros

Procedural macros for redbpf

alpm-rs

aplm bindings and wrapper for rust

kekbit

Ultralight persistent data channels

systemd-crontab-generator

Systemd generator for crontab files support

proc_getter

make retriving infomations from /proc/* easier

timerfd

A rust interface to the Linux kernel’s timerfd API

is-root

A simple library to detect whether you are root/admin or not

rsprocmaps

A Rust library for handling memory maps in procfs

etc-passwd

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

unix_socket

Unix domain socket bindings

cgroups

Native Rust crate for managing control groups on Linux

capsicum

Simple intuitive Rust bindings for the FreeBSD capsicum framework

xdg-mime

A library for loading and querying the XDG shared MIME database

simple_libc

Safe, friendly interfaces to some commonly used Unix libc functions

debcontrol

Parse Debian control files

pentacle

Executes programs as sealed anonymous files on Linux

netlink-packet-route

netlink packet types

hyper-unix-connector

Use hyper with unix-domain sockets

tipc

Bindings for interoperating with Linux TIPC sockets

filedesc

thin wrapper around raw file descriptors

input-event-codes

Linux input event codes form linux/input_event_codes.h

mtree

A crate for iterating through the entries of an mtree record file

parity-daemonize

A more advanced daemonizer

linux-futex

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

altaway

Simple code, nothing more

dakv_logger

Logger for dakv

epoch-timestamp

Boilerplate collection for epoch timestamping

fd

File descriptor utilities

linux_raw_input_rs

Simple library to grab raw input from keyboard in linux systems

osoy

Command-line git repository manager

nbd-netlink

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

soio

I/O library for Rust

probes

Library to read out system stats from a machine running Unix

newt-sys

Low-level bindings for the Newt console UI library

firestarter

A process and shared socket manager

kqueue-sys

Low-level kqueue interface for BSDs

sg3

A library for getting information from Linux SCSI Generic (sg3)

libxdo

Bindings to libxdo

dnsclient

A small, simple and secure DNS client library

ioslice

no_std I/O slices that are still optionally ABI compatible with std and lbc

unix_socket2

Unix domain socket bindings, with bug fixes and enhancements

wharf

Asynchronous docker api library

uinput

Linux uinput wrapper

raw_sync

Lightweight wrapper around OS synchronization primitives

genelf

A simple library for generating elf-binary

linux-aio-tokio

Tokio bindings for Linux kernel AIO

tokio-linux-aio

Tokio bindings for Linux kernel AIO

fg

fg bg implementation

dbus-macros

Convenient macros to use the dbus crate

rcore-os/linux-syscall

Linux syscalls implementation

sysexit

Exit codes for programs

gpio-utils

Command-line utilities for interacting with GPIOs under Linux This wraps the sysfs_gpio crate in a form usable by both Rust applications or any other applications

bystr

macro to create compile-time, fixed length, byte array from a string

gobject-2-0-sys

Import crate for GObject

sdnotify

Notify service manager about start-up completion and other daemon status changes

stdio-override

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

sdwd

SystemD WatchDog utility crate

pfly_rust

A crate to interact with the projectFly X-Plane IPC service

hydrogen

Multithreaded Linux TCP socket server using epoll

rlxc

A simple tool to interact with LXC containers

bpfjit-sys

Rust bindings to NetBSD’s cBPF JIT engine

minilibx

Rust ffi bindings to the 42 minilibx api for X11 on linux

utmp-raw

Provides raw types for parsing login records in utmp file

mnl

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

fedora-prime

Switching between intel/nvidia drivers made simple

udp_sas

Source address selection for UDP sockets

linux-taskstats

Rust interface to Linux taskstats

posixmq

An idiomatic posix message queue wrapper with optional mio integration

unicom-unix

Unix domain socket backend for unicom

k2i

Kernel Parameters Interface using HTTP

systemfd

A convenient helper for passing sockets into another process. Best to be combined with listenfd and cargo-watch.

servicefile

A rust crate for parsing /etc/services

raw-syscall-base

Low-level raw system call base

ioctl-gen

Simple macros for generating ioctl numbers

hciraw

The interface to HCI Raw Sockets

tiny-nix-ipc

Minimal wrapper for using sockets as IPC with file descriptor passing

libudev

Rust wrapper for libudev

deno-x86_64-unknown-linux-gnu

Binary dependencies for the ‘deno’ crate

mnt

Parse mount points

linapi

High level bindings to various Linux APIs and interfaces

lizhuohua/linux-kernel-module

ubuntu-version

Convert Ubuntu versions to codenames, and vice versa

crslmnl

A rust wrapper for libmnl

rosd

rosd is the most productive way to interact with roslaunch files in Rust because of its safe and composable abstractions over systemd

linicon

Look up icons and icon theme info on Linux

panty

Fast gVim summoner

nftnl-sys

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

dbus-launch

A D-Bus daemon launcher

rcin

Simple rust input streams

psi

Linux Pressure Stall Information (PSI) for Rust

longshoreman

asynchronous Docker client in pure Rust

lithos

A containerization framework for linux

unix-tty

Unix TTY API

acct

Crate for reading data from acct(5) files

shells

Sugar-coating for invoking shell commands directly from Rust

linux-usb-functionfs-sys

Naive translation of the Linux functionfs and USB chapter 9 headers

docker

Docker Remote API in Rust

bvm_filter

Virtual machine and JIT compiler for eBPF programs

udsx

Some extensions for Unix domain sockets

procinfo

A library for accessing Linux process and system information

gbm-rs

Rust bindings to libgbm

uio

Helper library for writing linux user-space drivers with UIO

unix-ipc

A minimal abstraction for IPC via unix sockets

libbpf-rs

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

xdotool

A wrapper for the command line tool xdotool written in Rust

auxv

Access the ELF auxiliary vector (aka auxv or auxval)

ctap-hid-fido2

Rust FIDO2 CTAP library

bpf

Attach BPF filters

unix_mode

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

syscall-alt

syscall-alt

unix-daemonize

Easy unix daemons support for Rust projects

connman

A ConnMan library that abstracts the D-Bus layer

rusty-keys

Linux keyboard mapper

os_socketaddr

A type for handling platform-native socket addresses (struct sockaddr)

unix-named-pipe

Ease creation of named pipes on Unix platform

acute_input

input sub-crate of acute

camctl_rs

A Rust rewrite of https://github.com/leaty/camctl

spirit-daemonize

Spirit helpers and config fragments to daemonize

i2c-linux

Linux I2C device interface

stemjail

Evolving jails for user activities

pseudoterm

Low-level library for creating PTYs

tabin-plugins

Libs for building nagios-compatible check scripts, some scripts, and some libs to read from /proc and /sys on Linux

subsystemctl

Utility to run systemd in WSL2 with a Linux namespace

libgssapi-sys

A low level binding to gssapi

uring

Pure Rust library for io_uring

desk-logind

Bindings for the systemd-logind D-Bus API

audit

linux audit via netlink

pop-os/apt-sources-lists

Library for fetching information from apt sources lists on the system

seccomp-droundy

higher-level bindings to libseccomp

fdstream

implementations of ::std::io::Read and ::std::io::Write for posix file descriptors

linux-api

Types and constants for Linux API bindings. Actual bindings can be found in additional crates found in dev-dependencies

ufmt-stdio

C stdio writer for ufmt

rcore-os/linux-object

Linux kernel objects

linux_mount_options

Detect file system, mount point and noatime of a folder the process has access to

statx-sys

Bindings to statx syscall implemented by syscall

input-linux

evdev and uinput

evdev

evdev interface for Linux

shmemfdrs

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

daemonizer

A simple library to privdrop and daemonize your program

systemd-rs

A high level systemd wrapper

async-unix

deleted - email help@crates.io to claim this crate name

tide-trace

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

sinit

A simple init system for use in containers

linux_proc

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

circadian

Linux auto-suspend/wake power management daemon

nsutils

Command-line utilities for making use of Linux namespaces

apt-cache

A rust crate to interface the apt-cache command

freedesktop-categories

Static hash map of all Freedesktop.org categories

search-provider

Rust wrapper around the gnome-shell search provider API

illumos-priv

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

industrial-io

Linux Industrial I/O (IIO) Support

docktape

Wrapping the Docker API

linux-perf-file-reader

Library for parse perf.data file from Linux perf tool

rctl

FreeBSD resource limits and accounting with RCTL / RACCT

embedded-ffi

OsStr and OsString for embedded usage

pine

Iterator over process line output

uinput-sys

Linux uinput definitions

unshare

The low-level interface for linux namespaces (containers)

joydev

Rust joydev library

calloop-dbus

EventSource to use DBus with the calloop event loop

mount-api

nix-like wrappper of the new linux mount api

dbus-tokio

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

libtor

Bundle and run Tor inside your own project

lpfs

Retriving infomations from linux proc filesystem

serial-unix

Serial port implementation for Unix

tokio-anyfd

Use any suitable file descriptor with tokio

posix-socket

thin wrapper around POSIX sockets

sendfd-new

Send file descriptors along with data over UNIX domain sockets

xkbcommon-sys

Bindings to libxkbcommon

systemd-boot-conf

Managing the systemd-boot loader configuration

glib-2-0-sys

Import crate for GLib

iptables

Rust bindings for iptables

netlink-proto

async netlink protocol