Vitaly Shukela

Command-line client for WebSockets, like netcat (or curl) for ws:// with advanced socat-like functions

A command-line tool for connecting to WebSocket servers from the terminal, like netcat but for WebSockets. It can also bridge WebSocket connections to TCP ports, UNIX sockets, or the input and output of external programs.

Redirect traffic to SOCKS5 server with iptables, epoll based, single threaded.

Simple evdev linux device driver and GUI program to simulate multitouch touchscreen

In Rust, format Duration into a string like "1 hour ago" or "01hou".

Simple websocket broadcaster implemented in Rust

Simple Python matroska (mkv) reading library, also mkv2xml and xml2mkv

Start programs inside unshare/lxc namespaces easily using UNIX sockets + easy access to capabilities, namespaces, chroot and others.

Read multiple fds and print data to stdout linewise.

Override time reporting in Linux processes (accelerate/slowdown games, test code involving timers/delays)

User-space Wireguard gateway allowing sharing network connection from environment where usual routing rules are inaccessible.

CLI tool to work with Sled key-value databases.

Simple UDP tun/tap-based tunnel with mcrypt encryption. Also some more AF_PACKET and tun/tap related tools.

Turn a bunch of scripts into a FUSE filesystem

Rust library for NBD (network block device) protocol.

xml2 for JSON; like gron

User-space TCP bandwidth limiter (based on tcprelay)

HEIC/HEIF decoder for imlib2 (feh)

Derive macro for Rust that turns traits into enums, providing tools for calling funtions over channels

Start Linux programs with only selected syscalls enabled (libseccomp-based)

Simple Rust STUN client library for resolving external IP address and port of a UDP socket

Android tool to exchange UDP packets

Android application to route incoming connections from Wireguard tunnels to device's network

Rust library to scan files and expand (make modules inline) multi-file crates source code as a single tree.

Simple DNS proxy with forced caching

Stress-testing tool for TURN (RFC 5766) servers.

AsyncRead/AsyncWrite stdin/stdout for legacy pre-0.1 Tokio

Linux CLI tool to forward TCP connections from one network namespace to another network namespace

Unified way to specify AF_INET or AF_UNIX address for listening sockets in Tokio projects (or inetd mode)

Simple Robin Hood hash table implemented using C macros

A simple NBD (network block device) server in Rust

HTTP POST and Server-sent events interconnector

[wip] Matroska/webm (mkv) parser in Zig

Trivial Android application that just shows bright red screen

Simple TURN client library for Rust, also a general-purpose TURN proxy.

LD_PRELOAD-based fopen/open filename overrider

In Rust, Expose Read+Write+Seek (or just Read+Seek) as a FUSE-backed regular file

Format f64 in Rust with minimum and maximum width, auto switching between scientific and normal representation

Low-level WebSocket frame encoding and decoding library for Rust

Simple alternative session establisher for mosh

P2P-friendly UDPv4-only user-space NAT for Linux. [beta]

Simple single-file FUSE implementation of copy-on-write

Simple low-level streamed callback-based CBOR push parser in C and C++

Display picture and print coordinates on clicks

Lock all pages in memory for a process tree

Various command-line tools, mostly for Linux

My attempt to solve https://github.com/kanaka/mal using Rust and Pest

CompactMap data structure for Rust

A CLI tool to concatenate rows from many csv files by matching columns of each

UDP relay with blowfish encryption

Mount network block device export as a single-file FUSE filesystem.

WebSocket mirror (echo server) implementation, for running services like echo.websocket.org

Dump mpegts files as XML, decoding various headers

Bridge Rust's `http` crate world and bytes world without a real web framework

A type-safe wrapper for Rust's "slab" data structure

FUSE single-file filesystem simulating dirty block device shutdown (each write is delayed randomly)

Mount one file to another (with offset and append_only support)

Command-line HTTP client for sending a POST request to specified URI on each stdin line.

Simple tool to send frames from pcap dump as udp packets

Rust mini-library to combine a reader and a writer into a Read+Write psedo-socket.

IPv6 router advertisment and neighbour discovery proxy for simple bridge-like extensions of /64 networks.

[WiP] Checks TCP tunnel/forwarder for correctness

Import cards into AnkiDroid from text files using API

AVIF loader for Imlib2/feh

Special FUSE filesystem to map /etc/resolv.conf to different files depending on Linux network namespace

UDP hole puncher for restrictive-ish NAT

Simple STUN server for testing purposes

Rust library and a command-line helper for Tribler REST API

Simple TCP forwarder that prepends some fixed bytes to responses and ignores some fixed header on requests

Storage for incremental backup/snapshots (as single big files)

FUSE application for mounting ZboxFS

imlib2 plugin for loading BPG images

Simple Linux epoll-based single thread TCP relay.

[incomplete] Library to work with Matroska (mkv) files in Rust

Command-line tool to perform curve25519 and ed25519 operations

Simple matroska (mkv) demuxer and muxer written in Haskell

Actively expose local UDP ports (e.g. Wireguard) using a simple relay server.

Simple REST service that executes scenarios consisting of command lines with timestamps (at which the commands should be run).

Simple low-level web server to serve file uploads with some shell scripting-friendly features

"iptables ... -p tcp -j REDIRECT" to this program and it will connect to SOCKS5 server

Command-line tool to generate samples of various random distributions

Temporal-median noise reduction video filter

Generates raw WAV output by hooking malloc() and read().

Virtual network for slowing down or dropping packets selectively

Command line tool to record proxied TCP traffic and use the recording to test clients or servers.

SQLite3 extension for opening Anki databases from other programs.

Tool to convert CSV table to a picture.

Web application for anonymous file sharing in intranet environments.

Command line tool to send and receive files over unidirectional UDP using Flute (RFC 6726)

Wireguard to GUE/FOU bridge: exchange IPv4 or IPV6 packets between a Wireguard peer and a plain UDP socket.

Mount cloop images (like in Knoppix) using FUSE

LED controller for Google Pixel 3 XL smartphone (requires root access)

Command-line tool to convert Twitch's *.rechat.json files to srt subtitles.

ALSA-based program to record from mic and immediately play it back

[work in progress] Network quality measurement tool (packet loss and delay statistics).

Rust API for Gaborator audio processing library

Command-line tool to run a dimensionality reduction algorithm on CSV files

Roundtrip CSV file, adding columns with values obtained using principal component analysis.

Small tool to resend received UDP datagrams back to known unexpired addresses; also small executable demo.

Use TURN servers as a relocatable communication channel

Command line tool to accept logs from stdin and allow "tapping" (i.e. subscribing) to them using sockets.

A WebSocket (RFC6455) library written in Rust

Accept TCP connections, read lines from them and write them to one zstd-compressed file

Simple http server in Rust (Windows/Mac/Linux)

A tool to measure audio/video synchronosation errors using special source video

Modified lpaq1 compressor for some additional features [hacky]

A test repository to demonstrate git merging and rebasing

Simple QT application that shows traffic light icon in systray based on stdin commands

FUSE filesystem based on Persy storage

Program to interpret circual gestures on a touchscreen and run program when enough winds are performed by user.

The rustup.sh script for installing Rust from release channels

Enhanced lsstack with periodic probing and output to file

A simple watchdog timer for Rust's Tokio async world

Useful shell scripts for /bin/sh

LD_PRELOAD library to make read/write/send/recv/etc. simulate short reads/writes

A fork of tokio_io::io::copy function that is more flexible.

Trivial Rust loger that just does println!, like the sample logger in documentation

Docker image to build for musl targets with Xargo

`impl proptest::Arbitrary for http::{Request,Response,Uri}` - random http-related objects generator for Rust

Data for this-week-in-rust.org

Better configuration for less

A text editor for programmers

A fast hash map/hash table (whatever you want to call it) for the C programming language.

Visualise (render to image) CSV table as coloured blocks

One-file interactive html table builder for data of some numerators with filters divided by denominators with the same filters

A modular toolkit for building fast, reliable Web applications and libraries with Rust and WASM

Tool to record from microphone and immediately play back fragmens based on silence fragments.

`tokio_test::io::Mock` analogue with more features

Rhai - An embedded scripting language for Rust.

A runtime for writing reliable asynchronous applications with Rust. Provides I/O, networking, scheduling, timers, ...

Graph editor library for egui

Cargo subcommand to provide various options useful for testing and continuous integration.

A simple, asynchronous, pure-Rust, structured, embedded database

CSVs sliced, diced & analyzed.

unix seqpacket sockets for tokio

Ringboard—the clipboard manager for Linux

🧡 Next generation information browser

MiUnlockTool developed to retrieve encryptData(token) for Xiaomi devices for unlocking bootloader, It is compatible with all platforms.

No description.

Simple Rust library to calculate Wilson confidence interval using the formula from Wikipedia.

Simple, Fast, Code first and Compile time generated OpenAPI documentation for Rust

Improving the binary size of Rust programs and libraries

Rust crate that provides number types similar to std's NonZero* types, but that cannot hold a type's maximum value instead.

Cranelift backend for rustc

Command line tool that reads simple BPG (Better Portable Graphics) files and dumps raw NALs that can be consumed by e.g. FFmpeg.

Scripts helping in PIT-38 calculation

Source code and logic to build OpenSSL from source

Ergonomic and modular web framework built with Tokio, Tower, and Hyper

The Rhai Book.

An HTTP library for Rust

Flexible concrete Error type built on std::error::Error

HTTP 2.0 client & server implementation for Rust.

Privacy enhanced BitTorrent client with P2P content discovery

Security advisory database for Rust crates published through crates.io

Authorizer is a Password Manager for Android. It emulates an HID keyboard over USB and enters your credentials on your target device. Additionally it supports OTP :key::mobile_phone_off:

Delegation of trait implementations via procedural macros

Mobile Shell

Derive macro to instantiate and register prometheus metrics without having to write tons of boilerplate code

Reproduction repository for the MDX 2021 Hybrid Demucs model

Pluggable critical section

A Rust compiler front-end for IDEs

No description.

Rust friendly bindings to *nix APIs

My attempt to experiment with WASM4 game framework

Listen to Alpaca minute bars over WebSocket and re-stream it, saving results to local database

A full featured, fast Command Line Argument Parser for Rust

Prototype to illustrate a point about TCP hangups in Tokio/mio

Modular, self-healing, and interface-oriented service manager and init system.

Error management

Take control of the Semver hazard of the `dyn` safety of your traits!

mirror of git://source.ffmpeg.org/ffmpeg.git

Home for the Unsafe Code Guidelines working group.

Semantic version parsing and comparison.

Safe interop between Rust and C++

the champagne of beta embedded databases

Simple Telegram bot that reads stdin and sends each line to specified group

A safe, concurrent, practical language.

My Crev Proofs

Abstraction over a file or block device that can be read/written with offset.

A circular buffer-like queue container.

Rust library for filesystems in userspace (FUSE)

Zero-cost futures and streams in Rust

mixed strategies game solver in Rust

A small crate to read and write pcap files in RUST.

A wav encoding and decoding library in Rust

Backtraces in Rust

GTK+ IRC client -

🦀 How to minimize Rust binary size 📦

Raw bindings to platform APIs for Rust

Decoders and encoders for STUN (RFC 5389) and its extensions

A Rust Implementation of TURN server and client

The parser of DNS protocol packets in rust

A bunch of lints to catch common mistakes and improve your Rust code

mal - Make a Lisp

🍻 Default formulae for the missing package manager for macOS

evdev and uinput for Rust

Record Query - A tool for doing record analysis and transformation

Synchronous memory pipe for Rust

Jitsi BRoadcasting Infrastructure

slices for `std::io::read` and `std::io::write`.

Krita is a free digital painting application. Digital Painting, Creative Freedom!