Lib.rs

nix

friendly bindings to *nix APIs

rustix

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

signal-hook

Unix signal handling

cairo-rs

bindings for the Cairo library

procfs

Interface to the linux procfs pseudo-filesystem

dbus

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

zbus

API for D-Bus communication

shell-words

Process command line according to parsing rules of UNIX shell

termios

Safe bindings for the termios library

x11-dl

X11 library bindings for Rust

seccompiler

seccomp-bpf jailing

pango

bindings for the Pango library

caps

pure-Rust library to work with Linux capabilities

daemonize

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

rlimit

Resource limits

uds

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

calloop

callback-based event loop

linux-loader

Linux kernel image loading crate

bluer

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

memfd

pure-Rust library to work with Linux memfd and sealing

ndk

Safe Rust bindings to the Android NDK

xremap

Dynamic key remapp for X and Wayland

ndk-sys

FFI bindings for the Android NDK

netlink-packet-core

netlink packet types

libproc

get information about running processes - for Mac OS X and Linux

gio

bindings for the Gio library

sys-mount

High level FFI binding around the sys mount & umount2 calls

listenfd

work with listenfds passed from the outside (systemd/catflap socket activation)

syslog

Send log messages to syslog

x11

bindings for Rust

x11-clipboard

x11 clipboard support for Rust

drm

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

bluez-async

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

sev

AMD SEV

automatic-timezoned

Automatically update system timezone based on location

syscalls

list of Linux system calls

cgroups-rs

Native Rust crate for managing control groups on Linux

rustbus

dbus protocol

nix-installer

Determinate Nix Installer

syd

seccomp and landlock based application sandbox with support for namespaces

rexpect

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

umask

deal with unix access mode

event-manager

Abstractions for implementing event based systems

mpris

Idiomatic MPRIS D-Bus interface library

alpm

bindings for libalpm

parui

TUI frontend for paru or yay

interprocess

communication toolkit

servicer

Simplify Service Management on systemd

vmm-sys-util

system utility set

rua

Secure jailed AUR helper for Arch Linux

libsystemd

pure-Rust client library to interact with systemd

hyperlocal

Hyper bindings for Unix domain sockets

bpf-linker

BPF static linker

youki

container runtime written in Rust

linux-package-analyzer

CLI tool to analyze Linux packages

gobject-sys

FFI bindings to libgobject-2.0

xkbcommon

bindings and wrappers for libxkbcommon

debcargo

Create a Debian package from a Cargo crate

gpiocdev

access GPIO lines on Linux using the GPIO character device

cli-clipboard

cross-platform library for getting and setting the contents of the OS-level clipboard

hysp

📦 An independent package manager that every hacker deserves

sysctl

Simplified interface to libc::sysctl

tokio-seqpacket

unix seqpacket sockets for tokio

zincati

Update agent for Fedora CoreOS

epoll

Safe epoll interface

rattler_virtual_packages

work with and detect Conda virtual packages

chirpstack_api

ChirpStack Protobuf / gRPC API definitions

drt-tools

Tools for Debian Release Team work

libcryptsetup-rs

High level Rust bindings for libcryptsetup

libmem

Advanced Game Hacking Library (Windows/Linux/FreeBSD)

landlock

LSM helpers

signal-hook-tokio

Tokio support for signal-hook

zeroconf

cross-platform library that wraps ZeroConf/mDNS implementations like Bonjour or Avahi

sevctl

Administrative utility for AMD SEV

libbpf-cargo

Cargo plugin to build bpf programs

command-fds

passing arbitrary file descriptors when spawning child processes

weresocool_analyze

audio analysis for WereSoCool

libnss

bindings for creating libnss modules

libbpf-rs

safe, idiomatic, and opinionated wrapper around libbpf-sys

runas

Run a command as root (sudo)

devd-rs

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

systemd-boot-friend-rs

Kernel version manager for systemd-boot

copypasta-ext

clipboard library providing useful extensions for copypasta

x11rb-protocol

bindings to X11

rbpf

Virtual machine and JIT compiler for eBPF programs

gag

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

os_type

Detect the operating system type

mpris-server

Implement MPRIS D-Bus interface in your application

jail_exporter

Prometheus exporter for FreeBSD jails

capctl

pure-Rust interface to prctl() and Linux capabilities

ruri

Calculates the CRC-32 of files and checks them against their filename

extrasafe

your code extrasafe by reducing what it can access

probes

read out system stats from a machine running Unix

memfile

memory backed files using memfd_create with file sealing support

file-owner

Set and get Unix file owner and group

waybar-module-pacman-updates

waybar module for Arch to show system updates available

drm-ffi

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

system_shutdown

shut down, reboot or log out operations

devicemapper

using Linux device mapper

xaskpass

lightweight passphrase dialog

oxidebpf

pure-Rust library for managing eBPF programs

mixxc

Minimalistic volume mixer

alpm-types

Types for Arch Linux Package Management

structured-logger

logging implementation for the log crate that logs structured values either synchronous or asynchronous, as JSON, CBOR, or any other format, into a file, stderr, stdout, or any other destination

libcontainer

container control

logind-zbus

dbus client (using zbus) for logind

twitter/rezolus

High resolution systems performance telemetry agent

timeout-readwrite

Adds timeout capabilities to Readers and Writers

systemctl

Small crate to interact with systemd units

xmas-elf

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

syscallz

seccomp library for rust

crate2nix

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

mprober-lib

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

dnsclient

small, simple and secure DNS client library

whome

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

terminal-clipboard

minimal cross-platform clipboard

pledge

binding to OpenBSD's pledge(2) interface

sgx

Intel SGX

lm-sensors

Hardware monitoring in Linux

capsicum

intuitive Rust bindings for the FreeBSD capsicum framework

libbpf-sys

bindings to libbpf from the Linux kernel

journal-forwarder

forward systemd-journald logs to an HTTP endpoint

tfc

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

shared_memory

user friendly crate that allows you to share memory between processes

zram-generator

Systemd unit generator for zram swap devices

uhid-virt

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

monitord

... know how happy your systemd is! 😊

privdrop

drop privileges

rs-release

os-release parser

xdgkit

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

uapi

Wrappers for OS APIs on UNIX-like platform

marswm

modern dynamic tiling window manager

fm-tui

TUI file manager inspired by dired and ranger

cvt

Expose the cvt function from Rust libstd

nmstate

networking management in a declarative manner

nixpacks

Generate an OCI compliant image based off app source

netlink-packet-route

netlink packet types

linux-procfs

data snap library for the /proc/ filesystem on the linux os

caterpillar

Detect and apply RAUC update bundles during boot

srt-c

API compatabile libsrt reimplementation using srt-tokio

kqueue-sys

Low-level kqueue interface for BSDs

hinawa

API bindings for hinawa library

nixpkgs-fmt

Nix code formatter for nixpkgs

perf-event2

interface to Linux performance monitoring

funzzy

fancy watcher inspired by entr

gpiocdev-cli

access GPIO lines on Linux using the GPIO character device

snap7-rs

snap7 C++ 库的 Rust 绑定，通过静态链接到 snap7，无需额外依赖。

zbus_polkit

PolicyKit binding

libblkid-rs

High level bindings for libblkid

blight

hassle-free CLI backlight utility/library for Linux

linux_modules

Manage Linux Kernel Modules

lwip

bindings for the lwIP TCP/IP stack

everything2

port of everything to Rust

xkbcommon-dl

Dynamically loaded xkbcommon and xkbcommon-x11 Rust bindings

tinyfiledialogs

High-level Rust binding for the tinyfiledialogs C library

printers

lib to get printers and print files on unix and windows

close_fds

that makes it easy to close all open file descriptors

pam-sys

FFI wrappers for the Linux Pluggable Authentication Modules (PAM)

yazi-fm

Yazi File Manager

oo7

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

proc-mounts

Fetch active mounts and swaps on a Linux system

alienware

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

ocipkg

OCI registry for package distribution

fiftyonedegrees

wrapper around the 51Degrees device detection C library

freedesktop_entry_parser

parsing FreeDesktop entry files

morganamilo/paru

Feature packed AUR helper

mustang

programs written entirely in Rust

deadnix

Find unused code in Nix projects

xkeysym

working with X11 keysyms

mkcd

if mkdir and cd were mixed together

gdk-pixbuf

bindings for the GdkPixbuf library

async-winit

winit like an async runtime

unixstring

FFI-friendly null-terminated byte string

read-process-memory

Read memory from another process

dbus-crossroads

Framework for writing D-Bus method handlers

tokio-gpiod

Linux GPIO character device interfacing with tokio

termsize

Retrieves terminal size

flo_render_gl_offscreen

Re-exports platform-appropriate libraries for initialising offscreen rendering

hinoko

API bindings for hinoko library

flatpak-rs

Flatpak library for Rust

rustix-openpty

Safe Rust bindings to openpty and related functions

interprocess-docfix

Interprocess communication toolkit. Docs fixed.

network-manager-connection-action

Execute commands on connections change using DBus network manager events

usb-gadget

Expose standard or fully custom USB peripherals (gadgets) through a USB device controller (UDC) on Linux

mmap-vec

Memory mapped vectors

kvm-bindings

FFI bindings to KVM generated using bindgen

xim

protocol parser, handler

uefi-run

Run UEFI applications

networkmanager

Bindings for the Linux NetworkManager

spotify-launcher

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

rs-drivelist

basically a Rust implementation of Balena’s drivelist

afetch

CLI system information tool written in Rust

extrasafe-multiarch

your code extrasafe by preventing it from calling unneeded syscalls

g213_colours

set the G213 keyboard backlight. Based on https://github.com/SebiTimeWaster/G213Colors.

linux-meminfo

efficient, zero-allocations /proc/meminfo parsing library

polkavm-linux-raw

Raw bindings to Linux kernel APIs

sd-listen-fds

Minimal, pure-rust helper to accept file descriptors from systemd

frc42_hasher

Filecoin FRC-0042 calling convention method hashing

mirrors-arch

ArchLinux mirrorlist retriever used by mirro-rs

ecc608-linux

accessing the ECC608 chip on Linux

unveil

binding for OpenBSD's unveil(2)

gaol

OS-level application sandboxing library

systeroid-core

Core library of systeroid

ixwindow

Iconized xwindow module for Polybar (for bspwm and i3wm)

daemonize-me

ease the task of creating daemons on unix-like systems

waitpid-any

Wait for any PID, an extension to waitpid(2)

rsprocmaps

handling memory maps in procfs

nix-editor

Some functions to modify NixOS configuration files

interrupts

Cross-architecture utilities for temporarily disabling interrupts and signals

udp_sas_async

Source address selection for UDP sockets

stdinman

Pipe audio to discord, unix style

pmc-rs

safe abstraction for interacting with Performance Monitor Counters on FreeBSD

posixmq

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

clipboard-sync

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

debian-packaging

Debian packaging primitives

containers-api

Common functionality used in podman-api and docker-api crates

aperture

GTK Widget for cameras using gstreamer and pipewire

oma-apt-sources-lists

fetching information from apt sources lists on the system

tldr-line-verifier

Command line tool to verify the max length of files in a repository

controlgroup

Native Rust crate for cgroup operations

glib-sys

FFI bindings to libglib-2.0

netlink-packet-sock-diag

netlink packet types for the sock_diag subprotocol

syscall-numbers

System calls numbers for various architectures

pamsm

wrappers around PAM Service Modules functions

pidfd_getfd

Binding to and a wrapper for the pidfd_getfd syscall

diss

dissociate program from your terminal

fd-queue

support fd passing on Unix sockets

rxscreen

wrapper around libx11 to capture screenshots and save them

debversion

Debian version parsing, manipulation and comparison

elfloader

load ELF files

servo-fontconfig-sys

Font configuration and customization library

below-gpu-stats

GPU stats crate for below

raminspect

arbitrary inspection and manipulation of the memory and code of a process on a Linux system

libgpiod

wrappers

dockerfile_builder

Flexible Dockerfile builder with type-safe features

btfdump

BTF introspection tool

alsa-sys

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

systemd-run

running processes as Systemd transient services

ashpd

XDG portals wrapper in Rust using zbus

aya

eBPF library with a focus on developer experience and operability

marsbar

Task bar for marswm (and other EWMH-compliant window managers)

signal-hook-mio

MIO support for signal-hook

netlink_wi

retrieve information about wireless hardware in Linux operating system using netlink protocol

hinix

High level *nix functionality in Rust

syslog-tls

Send log messages to syslog

drm-fourcc

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

partition-identity

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

cartes_rbpf

Virtual machine and JIT compiler for eBPF programs

hw-exception

Catch and handle hardware exceptions, such as page faults

rplc

PLC programming in Rust

linux_max6675

that reads temperature data from a MAX6675 over the Linux kernel's SPI API

process_migration

Overwrites a running process' next instruction(s) with shellcode (default to a reverse shell on localhost:4444)

daemonizr

Small crate which helps with writing daemon applications in Rust

shared_memory_extended

user friendly crate that allows you to share memory between processes

penrose_ui

UI elements for the penrose window manager library

linux-keyutils

interface to the Linux key-management facility. Provides a safe interface around the raw system calls allowing user-space programs to perform key manipulation.

log4rs-syslog

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

focus_monitor

iterating over the focused window each time it changes

linux-video

Linux V4L2 device interfacing

microcli

Bunch of random unrelated CLI tools

sesh-cli

CLI crate for Sesh, a Unix terminal session manager

freebsd-libgeom

bindings to FreeBSD's libgeom library

xrandr

Safe rust bindings to (some parts of) xrandr

speare

actor + eventbus lib

printnanny-asyncapi-models

PritnNanny AsyncAPI Rust models generated by Modelina

rupamix

PA Mixer is a cli tool for interfacing with Pulse Audio

weresocool_ast

AST for WereSoCool

limits-rs

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

elfcore

create ELF core dumps for processes on Linux

osmesa-sys

OSMesa library bindings for Rust

rd-hashd

Latency-sensitive pseudo workload for resctl-demo

docker_plugin

Scaffolding for implementing docker plugins in rust

aura-pm

Install and manage Arch Linux packages

outer_cgi

barebones CGI/FCGI wrapper

epoll-rs

High level bindings to linux's epoll interface

whattheshell

Infer the current shell the application is running on

rkill_lib

kill process by name, pid or port number

fs-verity

Produce fs-verity measurements in pure Rust, or access the Linux kernel APIs to freeze a file with fs-verity and get its digest

os-version

Get the operating system version

input-event-codes

Linux input event codes form linux/input_event_codes.h

posix-acl

interact with POSIX filesystem ACLs

ppk

find the port, and kill its process!

signal-handler

Signal Handler

ptrace-do

Featureful library for interacting with unix processes through ptrace, supports x86_64, i686, arm, aarch64 remote function calls

filedesc

thin wrapper around raw file descriptors

display-info

Cross-platform get display info

palaver

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

onix

Decode image files using V4L2

earst

Unix FIFO file library for Rust

exec

POSIX exec function to replace the running program with another

rustables

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

systemd-wake

systemd to wake up for future tasks

aur-fetch

libary for downloading and diffing AUR packages

bpf-compatible-rs

build BPF-compatible binaries in Rust

sensorhive-fbp-linux

Sensor Hive First Boot Provisioner

rsbash

run bash commands from rust

bluez-async-ots

Bluetooth Object Transfer Service (OTS) Client for bluez-async

procfs-core

Data structures and parsing for the linux procfs pseudo-filesystem

rs-car-ipfs

rs-car wrapper to read files from IPFS trustless gateways

rline

Input line retrieval using libreadline's "Alternate Interface"

le-petit-lapin

cute X window manager

shutdown

can be used to gracefully exit (part of) a running program

varlink-cli

varlink command line tool

libsdbootconf

systemd-boot configuration and boot entry configuration parser library

font-loader

font loading utility written in and for Rust

seccomp-sys

low-level bindings to libseccomp

hyper-unix-connector

hyper with unix-domain sockets

jail

FreeBSD jail library

linux-futex

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

pangocairo

bindings for the PangoCairo library

libcgroups

cgroup

bitness

detecting OS bitness independently of the executable's bitness. Windows, GNU/Linux and FreeBSD currently supported.

libvibrant

control screen saturation on X servers

system-hook

shook: webhook server to automatically update production servers

addy

POSIX interrupt handling that is both safe and ergonomic

drm-sys

Bindings to the Direct Rendering Manager API

debian-changelog

Parser for Debian changelog files

signalbool

catch signals and set a boolean flag for later use

scall

Friendlier raw system calls for Rust

systemd-rs

high level systemd wrapper

crosup-macros

CLI tool to quickly setup your development environment on Chomebook (ChromeOS) or any Linux Distribution

mmarinus

safe mmap implementation

do

rewrite of GNOME To Do in Rust and Relm4

errno-sys

Raw FFI bindings to errno location

keytar

bindings to safely interact with operating system keychains

linux-stat

pure Rust library that implements stat functions on linux with only syscalls

proc-cpuinfo

Read /proc/cpuinfo on Linux systems

zbus_systemd

pure-Rust library to interact with systemd DBus services

io_uring_header

linux kernel 6.1 include/uapi/linux/io_uring.h

docker-compose-runner

small helper for running docker-compose.yaml files

tokio-process-terminate

tokio process extension to terminate child processes

drives

listing mounted or mountable drives on linux

filterm

Filter terminal data to and from a child process

hyper-unix-socket

Default Unix Socket implementation for use with hyper

cgroups-fs

bindings to Linux Control Groups (cgroups)

find-binary-version

Identify binary versions easily

cntr-nix

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

errno-dragonfly

Exposes errno functionality to stable Rust on DragonFlyBSD

vfio-bindings

FFI bindings to vfio generated using bindgen

procps-sys

Interface with procps library on Linux

pwnwalk

Collect OS info covertly during Linux Enumeration, leaving zero traces

xproto

bindings to the X11 protocol library

nftnl

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

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…

linux-taskstats

interface to Linux taskstats

sd-id128

wrapper for sd-id128 implemented in libsystemd

mnl

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

mkdtemp

thin wrapper around libc's mkdtemp, UNIX only

fiemap

call ioctl FIEMAP on files with ease

hacksaw

Lightweight selection tool for usage in screenshot scripts etc

firepilot

Interface to work with Firecracker microVMs

syswall_cli

syswall_cli: a simple CLI to syswall

shmemfdrs

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

giit_rbpf

Virtual machine and JIT compiler for eBPF programs

bpfjit-sys

bindings to NetBSD's cBPF JIT engine

subsystemctl

run systemd in WSL2 with a Linux namespace

btf-rs

BPF type format (BTF)

or-tools-sys

Unofficial Rust wrappers to the C++ library Google OR-Tools, open source software for combinatorial optimization

aur-rpc

async wrapper for aur RPC calls

etc-passwd

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

libxdp-sys

bindings for libxdp

guzuta

Custom repository manager for ArchLinux pacman

zbus_names

collection of D-Bus bus names types

kcheck

Kernel configuration checking utility

usbfs

XML library in pure Rust

fast-walker

Multi-threaded directory walker, with async support

unix-watch

Unix watch command

gitprompt-rs

very simple Git prompt

hydrogen

Multithreaded Linux TCP socket server using epoll

cgroups

Native Rust crate for managing control groups on Linux

neovim-ctrl

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

libhook

Hook system calls

tide-trace

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

xdg-mime

loading and querying the XDG shared MIME database

linux-errno

Linux error numbers

signal-child

little library to easily signal other process with no dependencies

systemd-crontab-generator

Systemd generator for crontab files support

bpfdeploy-libbpf-sys

Fork of libbpf-sys

arch-toolbox

cli for manage arch linux utils

unshare

low-level interface for linux namespaces (containers)

sonde

compile USDT probes into a Rust library

ethercat-sys

Binding to the Etherlab open-source EtherCAT master

fsf

Fast Shell Finder, find and execute simple to complex commands quickly and easily

nixinfo

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

unix_socket2

Unix domain socket bindings, with bug fixes and enhancements

ioctls

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

runny

Run a program inside its own process group

snphost

Administrative utility for AMD SEV-SNP

crypt-sys

FFI wrappers for the Linux crypt library

tokio-fd

Non-blocking Read and Write a Linux File Descriptor

zwp-input-method-service

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

flatpak

Flatpak library for Rust

stdio-override

overriding Stdin/Stdout/Stderr with a different File Descriptor

clipboard_x11

obtain access to the X11 clipboard

aur-rs

interacting with the Arch User Repository's RPC interface

bpf-loader-lib

load json-described ebpf programs, and automatically poll outputs from the program

input-linux-sys

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

initus

init for linux

ubuntu-version

Convert Ubuntu versions to codenames, and vice versa

ioctl-rs

bindings for system ioctls

desk-logind

Bindings for the systemd-logind D-Bus API

syscall-alt

shellflip

Graceful process restarts in Rust

nbd-netlink

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

yazi-plugin

Yazi plugin system

evdi

High-level bindings for evdi

gtk-sys

FFI bindings to libgtk-3

slog-syslog

Syslog drain for slog-rs

tokio-timerfd

timerfd support for tokio

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

systemd_client

systemd client library implemented with zbus

peekpoke

- a lightweight Rust library for accessing physical addresses using /dev/mem in Linux

pango-sys

FFI bindings to libpango-1.0

rxdp

Bindings for interoperating with XDP programs and eBPF maps

journald

binding for the systemd journald api

systemd-zbus

dbus client (using zbus) for systemd

libxdo

Bindings to libxdo

utmp-raw

raw types for parsing login records in utmp file

linapi

High level bindings to various Linux APIs and interfaces

dbus-tokio

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

linicon

Look up icons and icon theme info on Linux

bulk

making deb packages, repositories, and update version numbers

blues

bindings to BlueZ (via zbus)

docker-source-checksum

Deterministic source-based docker image checksum

tokio-dbus

Pure Rust D-Bus implementation for Tokio

xkbcommon-sys

Bindings to libxkbcommon