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.
In Development , by Victor Perron | March 2013
satan is a C daemon that allows for easy remote management of OpenWRT platforms. It enables remote GET/SET of configuration properties, package update, firmware upgrade, remote command execution, remote package installation… And is extremely lightweight. Come contribute !
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.
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.
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.
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.
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.
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.
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
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()); s.send(reply1,ZMQ_SNDMORE); s.send(reply2);
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.
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.
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.
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!
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
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.
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
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.
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.
Written: 02 Aug 2010 18:48
Revised: 28 Mar 2013 07:36
If you found this page useful, please rate it up so others will find it.
- An Introduction to ØMQ
- Coding Style Guidelines
- Guidelines for ØMQ bindings
- Installing on Windows
- libzmq Source Git Repository
- Mailing Lists
- Message API Goals
- ØMQ Contribution Policy
- ØMQ Cookbook
- ØMQ Distributions
- ØMQ Owners
- ØMQ Release Policies
- ØMQ/2.1 Class Diagram
- ØMQ/3.0 Roadmap
- ØMQ/3.2 Roadmap
- Process Manager
- Projects using ØMQ
- Reporting and Tracking an Issue
- The native ØMQ API (libzmq)
- The ØMQ Guide
- The Ten Minute Talk
- Trademark Policy
- Tuning ØMQ
- Upgrading from 2.0 to 2.1
- Upgrading from libzmq 2.x to 3.2
- Using Valgrind
- Welcome from AMQP
Who's watching this page?pieterh
... and more