Paul Colomiets

Vagga is a containerization tool without daemons

The mio-based framework for rust for doing I/O in simple and composable way (ABANDONED)

A rust-macro which makes errors easy to write

The command-line argument parser library for rust

A fast HTTP/WebSocket to zeromq gateway (UNMAINTAINED, take a look at swindon web server instead)

The low-level linux containers creation library for rust

Process supervisor that supports linux containers

The mio/rotor based http server library for rust (UNMAINTAINED, use tk-http)

Rust KDL parser and derive implementation

The parser of DNS protocol packets in rust

A peer-to-peer synchronization software for servers in datacenters.

Yet another tiling window manager

A protocol on top of CBOR that provides protobuf-like functionality

Heartbeating and monitoring solution

Network communication library based on greenlets, with zeromq and redis support

An (unofficial) nginx configuration parser

A small wrapper around trafaret and yaml that does nice error reporting (python)

An HTTP and websocket protocol implementation for libev event loop (UNMAINTAINED, use rust and tk-http crate)

Simple dependency injection library for python2 and python3

A tool which manages cluster of services

A type-safe wrapper around mount() system call for rust with good error reporting

A library that allows to listen network sockets with proper resource limits and error handling

A thread pool for rust/tokio that can process file requests and send data to the socket with zero copy (using sendfile)

CPU time measurement library for rust

Signal handling for rust

A connection pool implementation for tokio

A wrapper around openat, symlinkat, and similar system calls

Abstract name service traits for rust

A template language for incremental-dom or DSL for javascript views

The stream abstraction on top of rotor (UNMAINTAINED, use tokio)

A rust crate with various helpers for writing production-ready servers in rust using async-std

Configuration file parser generator, that uses YAML for configuration files. Currently generates only C code

Devices and commandline tools for zeromq and crossroads io

A tiny library to measure resource usage of the process it's used in

Network buffers for rust

A rust reimplementation of a gron utility which makes JSON greppable (https://github.com/tomnomnom/gron)

A YAML-based configuration library for Rust

My futures/tokio tutorial for Rust Belt Rust (OUT OF DATE)

Parser of ssh public and private keys

A whitespace and memory friendly template engine

The asyncio client for Amazon S3

Compiler for Jade-like template language to cito.js-based virtual dom

A wrapper around rotor library for rust which provides C API and scripting language bindings

Sorted sets implementation in pure python

Process supervisor

A serde wrapper, that can be used to serialize data types using Display and FromStr

A tool that builds packages, updates package repos, and bumps versions

A httpbin reimplementation in rust

This is a prototype which brings vagga as the first-class tool to OS X and (possibly) windows through docker's layer of compatibility

Cython-based python bindings for libarchive

A YAMLy configuration parser-generator for C

A command-line tool for working with graphql written in rust

Thread-local loop and other simplifications for tokio loop

A virtualbox wrapper around vagga

An abstraction around domain name system that allows to resolve different names by different means

A flake8 lint to enforce that some modules can't be imported from other modules

A clone of unix "tail" utility which uses HTTP Range requests to watch remote files

A glob (file matching utility) with capture groups (similar to regex)

A serde wrapper that stores integer millisecond value for timestamps and durations (used similarly to serde_bytes)

Battle ship implementation in Nim language (hackaton project)

Generator of nix expressions from pythonic requirements.txt

A compiler of a python-like programming language, targeting the Flash platform

A simple PaaS inspired by dokku but built with vagga, cantal, lithos, verwalter, ciruela and possibly swindon

Another implementation of string interning in rust

The asyncio client for beanstalkd work queue

URL routing library for asyncio

A command-line utility and a rust library to validate and make certain tweaks/rewrites of nginx configs

A library to create a signature (or index) of the directory suitable for using by file synchronization utilities

A tool which helps to generate lithos config from a vagga config

(ABANDONED. Use `tk-carbon` instead) The asynchronous rust + rotor bindings for carbon (graphite)

Carbon client for tokio

a web interface for viewing collectd statistics

A library that allows to traverse data structures by path

Readline Implementation in Rust

AMF serializer/deserializer for python3

Redis implementation for rotor library (using mio in Rust language)

The cantal client library (on top of tokio main loop)

A easier read_dir for rust, useful for reading directory of config files

Python library for cantal

Go bindings to cantal

A human friendly format parser for numeric types

A buffered stream backed by contiguous buffers for tokio (rust)

Adds an `io::Write` interface on top of `digest::Digest`

Talk about asynchronous IO. WARNING: Presentation contains both good and bad examples without any markup. Use your own judgement.

Presentation for vagga

No description.

Presentation for "Ops for Dev" conference in Kyiv on 24.01.2015

:house_with_garden: Open source home automation that puts local control and privacy first.

A terminal workspace with batteries included

A string type for Rust that is not required to be valid UTF-8.

No description.

An unbounded channel that only stores last value sent made for futures-rs

A rust crate that deals with time-series data, initially written for, and battle-tested in cantal

A (prototype of) set of modules and test utilities to write a verwalter scheduler

A derive implementation for `trimmer::Variable` trait

An env_logger-inspired one-stop configuration for name resolution based on abstract-ns.

A rust library that allows having by-value futures (which improves type safety)

And experimental name service for nanomsg

Experimental rule-based namesystem for nanomsg

A HTTP renderer for self-meter data

Various tiny convenience tools for writing application using rotor in rust

An utility library which helps writing tests for rotor-based applications and libraries (work in progress)

A DNS resolver for rotor

Rust library to interface with Lua

Package manager for Arch Linux (pacman frontend)

No description.

A pure-python, ctypes based, PEP 249 compliant MySQL driver. Python3 port

Tar file reading/writing for Rust

Nix Packages collection

A readline replacement written in Rust

A language binding generator for WebAssembly interface types

Fancy upgrade to std::error::Error.

Here's where kdl.dev is hosted from.

Append-only collections for Rust where borrows to entries can outlive insertions

No description.

the kdl document language specifications

Tantivy is a full-text search engine library inspired by Lucene and written in Rust

Async interface for working with processes

Embryonic Rust TLS library

TLS API for Rust, and API implementations over native-tls and openssl in separate crates

A full featured, fast Command Line Argument Parser for Rust

The Rust toolchain installer

A HashMap wrapper that holds key-value pairs in insertion order

Slab allocator for Rust

The Python programming language

A logging implementation for `log` which is configured via an environment variable.

An implementation of regular expressions for Rust. This implementation uses finite automata and guarantees linear time matching on all inputs.

Assert process::Command - Easy command initialization and assertions.

Rust port of pexpect

A rudimentary password manager (unmaintained)

Async version of the Rust standard library

Serve the web – HTTP server framework

Low-level IO utilities for PosgtreSQL drivers.

Rust <-> Python bindings

JavaScript bindings for EdgeDB

Zero-cost futures and streams in Rust

EdgeDB Python Driver

The next generation relational database.

Logging implementation for Rust

Simple time handling in Rust

Rust framework for making client web apps

Metal IO library for Rust

Datepicker react component based on semantic-ui-react components

Python Classes Without Boilerplate

Python profile viewer

Collection of library stubs for Python, with static types

Morphological analyzer / inflection engine for Russian and Ukrainian languages rewritten in Rust

Beanstalk is a simple, fast work queue.

Executes commands in response to file modifications

multidict implementation

Design Framework

A presentation of ciruela for uapycon

👾 filter your json logs with graphql 👾

RFCs for changes to Rust

A library to work with CIDRs in rust

HTTP date parsing and formatting

GraphQL server library for Rust

No description.

A Rust GraphQL server framework

Library for extracting marketing attribution data from referrer URLs

Python bundler-alike alternative to virtualenv

Just test project

URL parser for Rust

A Rust based DNS client and server

preact wrapper for "Material Components for the web"

Python client for CockroachDB

Mirror of the official PostgreSQL GIT repository. Note that this is just a *mirror* - we don't work with pull requests on github. To contribute, please see http://wiki.postgresql.org/wiki/Submitting_a_Patch

Rust bindings for the Python interpreter

Github mirror of Alembic

A routing that perfectly fits khufu model

CBOR serialization and deserialization using serde.

A library for creating references that carry their owner with them.

A presentation for rustfest.eu 2017

The Rust website

A template engine for Rust based on Jinja2/Django

No description.

Rust library for cantal

ZeroMQ core engine in C++, implements ZMTP/3.0

The package generator for Archlinux kernel supporting user namespaces

http client/server for asyncio (PEP-3156)

my `util-linux` fork

Rust LDAP Library

(work in progress) FUSE-MT: a multithreaded wrapper on top of FUSE for Rust

No description.

Generic array types in Rust

Slides for my talk on XP days 2016

I/O primitives and event loop for async I/O in Rust

Redis client for Tokio

Rust HTTP lib

validate arbitrary data structures in python and javascript

LDAP authentication module for nginx

Asynchronous name resolution utilities for the futures and tokio-core crates.

Vagga presentation for OSDN conference

A talk about strace for internship in evo.company

Docker Remote API in Rust

A two-page cheatsheet for restructured text

Presentation of orchestration system

My presentation for UA PyCon 2016

Lua 5.3 bindings for Rust

Vagrant plugin with vagga provisioner