2015-08-08 - Baratine 0.10.0 available for download

Baratine 0.10.0 has redesigned the streaming interface, simplified ServiceRef and ServiceManager, improved RPC performance and jamp-rpc performance. Read through the release notes, see the JavaDoc or head over to the download to try them for yourself.

2015-05-20 - Baratine 0.9.0 available for download

Baratine 0.9.0 adds static pages to support single-page applications. Session services have been simplified; they are now @Service with a "session:" url. The javascript/jamp library has been updated. Performance improvements for the jamp-rpc HTTP style. Read through the release notes or head over to the download to try them for yourself.

2015-03-29 - Baratine 0.8.8 available for download

Baratine 0.8.8 introduces several important lifecycle updates for services. With the additional capabilities @Service replaces the older @ServiceResource.Read through the release notes or head over to the download to try them for yourself.

2014-10-01 - Baratine at Silicon Valley JUG October 15

Caucho to present Baratine at the Silicon Valley JUG on October 15th held at Google's HQ. Meet senior Caucho Engineer Nam Nguyen and Chief Evangelist Sean Wiley.

Introducing Baratine

Baratine is a new distributed in-memory Java service platform for building high performance web services that combine both data and logic in the same JVM. Say again? In Baratine, the data lives within the service and the service owns its own data. This means:

  1. the data is not owned by the database
  2. the data is not modified by another process
  3. the data is not separate and distinct from the service

=> The data sits right in the service in the same JVM, the same thread, and the same class instance.

How does it all work?

In Baratine, your plain-old-Java-object (POJO) is your service and the fields in the class are your data. Your POJO stays in memory and it holds the authoritative copy of your data. Your service runs at the speed of light because it never has to wait for the database because the data is already there in memory within the service. Baratine does save your data to an internal database in the background for persistence (but that copy is just a backup for recovering from restarts).

Baratine goes above and beyond NoSQL - Baratine is NoDB. Because the POJO is both the service and the data, the database's role is relegated to backup. The POJO has what it needs to complete a request front and center.

Baratine is high-performance

Baratine is single-threaded to enforce a single-owner, single-writer contract. The POJO is the only one able to modify its data because it owns its own fields; there is no need for synchronization and intermediaries (databases or API calls). Without intermediaries and without synchronization, Baratine services are super, super fast.

Baratine's Architecture

The following components make up Baratine:

  • Inbox: ring-buffer queue
  • Journal
  • Distributed SQL-compatible database
  • BFS (Baratine File System): distributed file system
  • Bartender: cloud manager with heartbeats
  • Horizontal scaling with automatic partitioning
  • Web server

Your POJO service

Given your POJO class:

public class CounterService
  private long _id;
  private long _count;

  public long get()
    return _count;

  public long incrementAndGet()
    return ++_count;

  public long decrementAndGet()
    return --_count;

  public long addAndGet(long value)
    _count += value;

    return _count;

Baratine wraps an Inbox, Journal, and distributed SQL-compatible database around your POJO. Baratine then exposes your POJO to blocking and non-blocking RPC calls from Java, WebSocket, and HTTP clients. For example, the following blocking HTTP RPC call:


would return the current counter value in JSON:


Learn more

Manufactured by Caucho Technology, Inc.