1. Trivial to integrate

    Add peer discovery to your application in 10 lines of code or less.
  2. Automatic peer discovery

    Use Journeta::Engine#known_peers to find other applications on the network.
  3. Object broadcast

    Send arbitrary Ruby objects to peers.
  4. Direct objects transfer

    Send directly to a given peer UUID.
  5. Cross platform

    Runs on Linux and OS X.
  6. Pure Ruby

    No native dependancies!


A “peer” is represented by a “start”ed instance of JournetaEngine in your Ruby application. You’ll probably want just one, but may run more if it makes sense for your application to logically represent two (or more) peers simultaneously, or want to run multiple instances on the same machine.

Any object that can be serialized via YAML can be sent and received by Journeta. Received messages (a.k.a. objects defined by your application sent from a peer running the same code) are passed into a message handler you provide in an event-based manner. Messages do not come from your applications main thread!

Journeta is simple because it doesn’t..

  1. Work outside the LAN

    Presence broadcasts don’t propagate to the internet, and there is no such thing as a “server” in Journeta.
  2. Currently use secure channels

    All network messages are currently sent in raw form across the network, and messages from peers are implicitly authorized. Engine-level support for encryption and authentication will be coming in the future.
  3. Dictate your message handling model

    Remember that events sent to your message handler each come from their own thread, and sometimes concurrently. Update only thread-safe data structure and/or design out the problem.
  4. Guarantee backwards compatibility

    No formal messaging specifications here. We will try to maintain interface compatibility between point releases (for example between 0.1.0 and 0.1.1), but we don't normally compatibility test across releases so your milage may vary.
  5. Guarantee message delivery

    Peers are free to go down at any time, or may flat-out refuse to ignore your presence.

Coming Soon

  1. P2P encryption and handshaking

    Communication currently are not secure and should only be used in a trusted environment.
  2. JRuby support

    We need your support to change a couple lines of Ruby socket API code to something JRuby can handle.
  3. Additional engine hooks

    This will allow you to tap into internal workings of Journeta to override default event handling mechanisms. For example, you'll be able to override the default (YAML) serializer.
  4. Preemptive peer reaping

    To remove peers from the engine if they have not been heard from in a while.
  5. Failure callbacks

    To allow your application to respond to peers going down before all outgoing information has been sent.