ØMQ Labs

There are many people working on interesting things around ØMQ. Here we collect ideas, works in progress, and projects by the ØMQ community. Feel free to add topics that interest you or that you're working on, using ØMQ. Stick to the format of other entries, and add your entry at the top. Thanks to Matt Weinstein for the sketch.


Production-ready, by 42ITy Team | 2017

The 42ITy™ project promotes the global development, distribution and adoption of the 42ITy™ platform as a next generation Data Center Service Optimization enablement platform.
The goal is to serve developers, users and the entire data center ecosystem by providing a set of shared resources to grow the adoption of 42ITy™ as the only open source, next generation Data Center Service Optimization enablement platform.
See our website or proceed to github.



easy_py_messaging: A simple to use python wrapper around ZeroMQ for distributed systems to use for messaging and logging. Especially targeted to noobies working with Raspberry Pi systems. Implements a simple synchronous messaging system and a centralized log collector. Works well for messages in distributed systems. Extensive documentation and examples assists beginners in python and messaging.

zmq, zmq-shell-tools (Shell)

Production-ready, by pbdR Core Team | 2016

zmq is a shell wrapper for REQ sockets. It can be used to send single or multi-part REQ messages to an already open REP socket. implement an efficient yet secure client/server framework to provide a multi-platform command-line interface for interactive pbdR. The packages integrate both ZeroMQ and MPI libraries to enhance native R capability on supercomputers for high performance computing with Big Data. The packages are formally released in source or binary files with elaborated documents on CRAN. All packages also support major systems: Linux, OS X, Windows, and Solaris.

pbdZMQ, remoter and pbdCS (R and pbdR)

Production-ready, by pbdR Core Team | 2016

The pbdZMQ, remoter and pbdCS packages implement an efficient yet secure client/server framework to provide a multi-platform command-line interface for interactive pbdR. The packages integrate both ZeroMQ and MPI libraries to enhance native R capability on supercomputers for high performance computing with Big Data. The packages are formally released in source or binary files with elaborated documents on CRAN. All packages also support major systems: Linux, OS X, Windows, and Solaris.

ZeroEQ (C++)

Production-ready, by Human Brain Project | 2016

Zero Event Queue is a cross-platform C++ library to publish and subscribe for events. Applications communicate using ZeroMQ, discover each other automatically through the integrated ZeroConf protocol or through explicit addressing using hostname and port. A defined vocabulary defines semantics for the published events, provided by ZeroBuf or using a simple Serializable
interface. An optional http::Server provides a web service API in C++ applications.

fail2ban-zmq-tools (Python)

Beta, by Buanzo | 2015

fail2ban-zmq-tools is a set of three python scripts that implement fail2ban clustering on top of zeromq REQ/REP and PUB/SUB sockets. Fail2ban is a great tool that monitors logs for attacks, and execute actions on the attackers, such as firewalling, mailing abuse@ISP, etc. By clustering fail2ban using fail2ban-zmq-tools, you can share ban data.

pseud (Python)

Beta-ready, by Nicolas Delaby | 2014

pseud is a bidirectional-rpc (server can initiate calls to its connected clients) API built on top of pyzmq with pluggable encryption (curve), authentication and heartbeating support.

nimrod-ipc - simple-to-use, multi-thread friendly, RMI and PubSub API for Java built on top of ZeroMQ.

Beta, by Andy Crutchlow | July 2014

This API covers two major use-cases which I find useful when developing enterprise/distributed java applications whilst requiring minimal configuration and code to use. More detail and code along with examples provided at my open github repository.

NetMQ.WebSockets - Extension to NetMQ that add WebSockets support.

Beta, by somdoron | June 2014

NetMQ.WebSockets is an extension to NetMQ, implemented using Stream socket type and providing a NetMQ like interface. Can be downloaded from nuget. Communicate with JSMQ on the browser side.

agent_zmq - Agent framework designed for testing ZeroMQ Applications with Cucumber

Production-ready, by Connamara Systems | September 2013

agent_zmq is an open source Ruby implemented agent framework for testing ZeroMQ applications. The library allows easy integration with Cucumber step definitions. Contributions welcome!

Zato - ESB, SOA, REST and cloud integrations in Python

Production-ready, by Dariusz Suchojad | September 2013

Zato is a Python-based solution for integrating applications and building backend servers. The platform offers trivially easy access to ZeroMQ out of the box.

Other protocols, standards and features include HTTP, JSON, SOAP, SQL, AMQP, JMS WebSphere MQ, Redis NoSQL and FTP. There’s a browser-based GUI, CLI, API, security, statistics, job scheduler, HAProxy-based load balancer and hot-deployment.

Click here and here for ZeroMQ usage examples.


Ready to test, by Lukas Vacek | February 2013

avis_zmqprx is a fork of Avis Router (written in Java) which adds support for zeromq and thus working as a proxy between ZeroMQ and Avis(elvin) middleware - this is handy because Avis is, at the moment, only supported middleware in OpenMama.

Pizco (Python)

Beta-ready, by Hernan Grecco | 2012-2013

Pizco is Python module/package that allows python objects to communicate. Objects can be exposed to other process in the same computer or over the network, allowing clear separation of concerns, resources and permissions.

Pizco supports calling methods from remote objects and also accessing their attributes, dictionary attributes and properties. Most importantly, using a Qt-like (and Qt compatible!) signal and slot mechanism you can easily register notifications.

Docs: [https://pizco.readthedocs.org/]

Zero-cache (C++)

Beta-ready, by Ilya Shpigor | 2012

Zero-cache is a Open Source cross-platform distributed memory caching system based on ZMQ messaging library.

Zero-cache is able to store data of any type that is addressed by key of string type. It provides the minimal response time thanks to multi-thread containers and absence of mutexes for requests synchronization. All synchronization is performed by messages processing mechanism. Both Unix socket and TCP socket based connections are supported.

There are language bindings for Python and PHP clients.

Cloudless (C++)

Beta-ready, by Databracket | 2011 - 2012

Cloudless is an event-driven communication framework built on-top of 0MQ to provide fast, reliable, easy-to-use library to address most application needs for communication over in-process, inter-process, or over the wire transports. Cloudless comes in as a transparent abstraction layer on-top of 0MQ to provide an ever-expanding set of communication devices and ultimately allow for constructing virtual networks with high level routing and abstract node descriptors. It wraps 0MQ's API with a version agnostic interface which allows developers to focus on building abstract communication constructs without worrying about 0MQ's details.

ZeroRPC (Python)

Production-ready, by dotCloud | 2010 - 2012

ZeroRPC is a modern communication layer for distributed systems, developed by dotCloud in 2010 and open-sourced in 2012. It features a dead-simple API for exposing any object or module over the network, and a powerful gevent implementation which supports multiple ZMQ socket types, streaming, heartbeats and more. It also includes a simple command-line tool for interactive querying and introspection. The platform team at dotCloud uses it in production to transmit millions of messages per day across hundreds of services.

Rpclib (Python)

Ready to test, by Burak Arslan | 21 Mar 2012

Rpclib is a general purpose RPC framework for Python. Rpclib comes with the implementations of popular transport, protocol and interface document standards along with an easy-to-use API that lets you build on existing functionality. It also nicely integrates with frameworks like twisted. It currently supports ZeroMQ as a transport in a both client and server setting, using REQ/REP sockets. Soap, HttpRpc, JsonObject, XmlObject are some of the supported protocols.

Process Manager

In Development, by John Skaller | 2012

Tools to launch and manage processes, driven by the need to actually test the 0MQ Guide examples to ensure that they compile and run as expected automatically, so the testing can be included in a background script.

Discussion Process Manager

Cocaine Distributed Application Server

In Development, by Andrey Sibiryov and Rim Zaidullin | 2011 - 2012

Cocaine is a fast and lightweight open source platform providing tools and infrastructure components to build your own PaaS cloud. One of the core components is multi-language (you can easily write your own language binding) event-driven (also, you can easily write your own event drivers) task-based distributed application server built on top of ZeroMQ transport and MessagePack serialization library. Yeah, it is cool.

ZmqMessage C++ library

Ready to test, by Phorm, Inc. | 2011

If your sense of beauty is not happy with code like

zmq::message_t reply1(hello.size());
memcpy(static_cast<char*>(reply1.data()), hello.data(), hello.size());
zmq::message_t reply2(world.size());
memcpy(static_cast<char*>(reply2.data()), world.data(), world.size());

and prefers something like
reply << hello << world << ZmqMessage::Flush;

ZmqMessage C++ Library is what you need.

Project code: github

gevent-zeromq - ZeroMQ compatibility library for gevent (Python)

Ready to test, by Travis Cline | 29 July 2011

Combine fast, cheap green threads in Python via gevent and ZeroMQ's power gevent-zeromq.

Rsyslog ZeroMQ Input / Output Plugins

Ready to test, by Aggregate Knowledge | 26 May 2011

Aggregate Knowledge has released ZeroMQ Rsyslog Plugins open source. These plugins allow rsyslog to receive and send data over zmq push / pull sockets (pub/sub coming soon).

Objective C ZMQ Socket Helper (wrapper over czmq zmsg class)

Ready to test, by Michael Zaccari | 17 May 2011

I wrote this simple Objective C wrapper to help manage sockets within an Objective C class. This uses the zmsg class provided by iMatix. I hope this helps anyone who is looking for examples of using ZeroMQ with Objective C.

Salt (Python)

Ready to test, by Thomas S Hatch | 29 April 2011

Salt is a distributed remote execution system used to execute commands and query data. Salt is meant to solve the problem of managing large sets of servers. It was developed in order to bring the best solutions found in the world of remote execution together and make them better, faster and more malleable. Salt is a great example of secure pub-sub over ZeroMQ, and scales to hundreds or thousands of servers.

EM-ZeroMQ (Ruby)

Ready to test, by Andrew Cholakian | 5 Feb 2011

EM-ZeroMQ Is a low-level interface to ZeroMQ sockets that hooks into the reactor loop of Ruby's EventMachine library. This requires 2.1.x+ versions of ZeroMQ, as it requires ZMQ_FD support to hook into EventMachine's select/epoll loop.

Evented interface to ZeroMQ sockets (Lua)

Ready to test, by Robert G. Jakabosky | 24 Dec 2010

lua-handlers is a lua wrapper of lua-zmq & lua-ev that provides an evented interface to ZeroMQ sockets. It allows you to send & recv messages on many ZeroMQ, TCP & UDP sockets at the same time.

Zeromqt (Qt)

Pre-alpha, by Steve Atkins

Zeromqt integrates ZeroMQ (version 2.1.0 and later) into the Qt event loop, mapping ZeroMQ message events onto Qt signals. It also provides an API that is more "Qt-like" than the native ZeroMQ C or C++ APIs, allowing messages to be handled as QByteArrays and providing classes that are similar in style to QAbstractSocket.

nzmqt (Qt) - A lightweight C++ Qt binding for ZeroMQ

Ready to test, by Johann Duscher

nzmqt is a re-implementation of Zeromqt which integrates ZeroMQ into Qt's event loop. However, nzmqt builds upon ZeroMQ's official C++ binding, cleanly places code into a separate namespace, adds multi-part message support, and not only works with PUB-SUB protocol, but also with REQ-REP and PUSH-PULL protocol. Included samples show those protocols in action, together with exception handling in Qt. Furthermore, the source code is officially released under the corporate-friendly BSD license.

C++ wrapper of zmq::poll

Ready to test, by Radu Braniste | 25 Aug 2010

Why another wrapper? The usual idiom used when writing zmq::poll based code is based on a block of if_conditions, testing for the occurrence of one event or the other. This might be error prone and hard to maintain in the long run. And this is where the wrapper comes handy: it separates poll functionality from actions and state (4 different ways to do it) and provides the boiler plate of zmq::poll functionality. Hope you'll find it useful!

Electricity Monitoring

In progress, by Bob Scott | 23 Aug 2010

I am using ZeroMQ for message passing between small components running on a PlugComputer for 24/7 electricity monitoring. I use the pub-sub pattern for publishing data from the logger and request-reply for a charting client and data server. I chose ZeroMQ for this application because of its ease of use, brokerless design, flexibilty of messaging patterns and transport and large number of language bindings.


In progress, by Andrew Cholakian | 16 August 2010

DripDrop is a Ruby / Javascript framework for building apps quickly using a reactor pattern. ZeroMQ is baked in at the core. It provides a common serialization format (based on BERT or JSON), and lets you seamlessly bridge HTTP, WebSockets, and ZeroMQ using a terse and readable syntax. Essentially, DripDrop exposes a common interface across a large number of protocols, letting you focus on your service, not the implementation details.


In progress, by Jeff Plaisance | 16 August 2010

JeffMQ is a peer to peer message queue framework. It is built on top of ZeroMQ and uses a queue binding system similar to AMQP. There are no special nodes or single points of failure. Queues can only be accessed from the node they are created on. There is no replication, if the node dies the messages are gone.

0MQ plugin for RabbitMQ

In progress, by Michael Bridgen | 16 August 2010

The purpose of this plugin is to provision ZeroMQ sockets that relay messages into RabbitMQ. Each ZeroMQ socket type is given an idiomatic encoding in the AMQP broker model, which means AMQP clients can interoperate.


In progress, by ProDataLab | 12 August 2010

ProDataLab is an FBP environment that takes advantage of every possible efficiency in processing data via streams. The intention is to build an extremely flexible, parallel, infinitely scalable, distributed application services system for every type and size of data set — processing, analyzing, learning, plotting and reporting, etc. Fast, efficient ZeroMQ messaging will be used as the core of ProDataLab's communication fabric. ProDataLab will eat extremely large data sets for breakfast.

ZMQMachine (Ruby)

Feature complete, by Chuck Remes | 4 August 2010

ZMQMachine is a Ruby library implementing the well-known reactor pattern using 0mq sockets. The API is heavily influenced by the popular Ruby Eventmachine library. All socket I/O activity is non-blocking. Program logic is implemented via asynchronous callbacks and/or handler classes that conform to a specific API. Documentation is limited, but familiarity with Eventmachine will resolve most questions.

TCP thin streams

Idea, by by Steven McCoy | 2 August 2010

A wide range of Internet-based services that use reliable transport protocols display what we call thin-stream properties. This means that the application sends data with such a low rate that the retransmission mechanisms of the transport protocol are not fully effective. In time-dependent scenarios (like online games, control systems or some sensor networks) where the user experience depends on the data delivery latency, packet loss can be devastating for the service quality. Extreme latencies are caused by TCP's dependency on the arrival of new data from the application to trigger retransmissions effectively through fast retransmit instead of waiting for long timeouts. — LWN.net

Parallel sort

In-progress, by Oliver Smith | 2 August 2010

So, I decided to try and figure out how to implement a parallel sort with ZeroMQ message passing.

Throw-nothing API (C++)

Ready-to-test, by Matt Weinstein | 1 August 2010

I've derived a "throw nothing" version of zmq.hpp. The functions are in namespace zmq::nothrow:: I've posted it up to github at: git://github.com/mjw9100/zmq_nothrow.git. Comments welcome. Best, Matt

Reactor pattern (C++)

Ready to test, by Matt Weinstein | 30 July 2010

Folks, I've submitted a reactor pattern for ØMQ to github at git://github.com/mjw9100/zmq_reactor.git. This pattern allow complex arrangements of sockets to be polled in arbitrary ways. The essential way to use this: 1- Create a bunch of zmq_reactors, 2- Link them in the right order into list, 3- Tell zmq_reactor_poll to poll them.

Async::Worker (C++)

Ready to test, by Oliver Smith | 22 July 2010

What I was looking for was a convenient C++ way of creating work-splitting tasks and work-delegating tasks. Having cut my teeth on ZeroMQ I immediately to making a worker pool system. The result is Async::Worker. It combines concepts from OpenMP and Intel's TBB. On a virtual quad-core machine building with -O0 I see a 35-40% reduction in processing time.

The Mongrel2 Web Server

Ready to test, by Zed Shaw | 22 July 2010

Mongrel2 is the complete redesign of the Mongrel web server to be an application, language, and network architecture agnostic web server. It's written by the original author of Mongrel, and uses the Mongrel HTTP parser, but everything else is new. The goal is to create a web server specifically designed for web applications over serving files.

grun job scheduler

Ready to test, by Erik Aronesty | 1 July 2013

grun is an extremely lightweight job scheduler written in Perl. It was originally written using POSIX sockets, and has been completely rebuilt using ZMQ. The goal is to create something that's "good enough" to replace gargantuan job schedulers like SGE and Torque. The current beta version uses ZMQ::LibZMQ3, works in production, but the feature set isn't locked down enough to call it a "release".


In development, by Michael Holmwood & Rafsan Siraj | 19 August 2013

We are looking to add support for the SCTP protocol to ØMQ. Our aim is to bring all of the benefits of SCTP to ØMQ. During development we will be performing tests and benchmarks to show the improvements in reliability and latency SCTP should have over TCP.


In development, by Oscar González | 02 October 2013

With ABADE the developer only has to define the tasks and the order in which they run.
ABADE flow analyzer, decide the best execution environment pondering the weight of function execution and communication between different machines.
ABADE services, execute the initialization process requests, launch execution.