Page tree

Versions Compared


  • This line was added.
  • This line was removed.
  • Formatting was changed.



CrossWorlds is a feature extension to IBM Websphere Liberty that gives direct Java access to a Domino server or Client. It requires:

  • A Websphere Liberty feature that wraps OpenNTF Domino API and five Domino jar files.
  • A variable with a path to a Domino server or Notes Client
  • A j2eeenabler jar file in the build path of any application that wants to use the filter

IBM Websphere Liberty

IBM Websphere Liberty is a lightweight Java EE server, analagous to Apache Tomcat. It is free for development or test use, as well as for limites production use. It can be installed and configured in Eclipse via a plugin available in the Eclipse Marketplace. It can be set up within a few minutes. Websphere Liberty supports Java 8, unlike full Websphere or Domino1.


 Domino is a very powerful server. Amongst many other features, it provides:

  • A NoSQL datastore (the NSF - Notes Storage Facility)
  • A repository for templates for NoSQL datastores (the NTF - Notes Template Facility)
  • A rich object model for manipulating the Domino environment, including servers in other domains. This can be done from LotusScript, Java, or Server-Side JavaScript (a JavaScript-like server-side language that abstracts the Java layer)
  • Mail routing and an SMTP gateway
  • Authentication via a main Domino Directory, extensible via Directory Assistance, LDAP, and more
  • Scheduled process management (Agent Manager) via tasks coded in an NSF using Java or LotusScript (Agents)
  • Clustering of servers
  • Replication of datastores via flexible replication schedules and with simple of complex selection criteria
  • A GUI-based administration client (often taken for granted, but has been on some people's wish lists for more powerful products like IBM Connections)
  • A GUI-based development IDE, struggling from being based on an old version of Eclipse, but flexible
  • Design architectures for deploying user interfaces via a rich client or web
  • An in-built HTTP server (nhttp)
  • An extensibile plugin architecture
  • A mechanism to dynamically load plugins at runtime (Update Site database, which can be replicated, since 8.5.3)
  • An in-built servlet engine using Servlet 2.5 specification (Equinox HTTP Service, since 8.5.3)
  • An in-built OSGi container environment to run web applications wrapped in an OSGi plugin (Expeditor Web Container, since 8.5.3)
  • An in-built full-text indexing engine
  • No doubt other elements I've forgotten

These are all available out of the box! Domino is regularly under-valued and compared pejoratively to other products that offer better options for part of what Domino provides. But never do they compare all features.

On top of this, the OpenNTF Domino API (ODA) provides:

  • Automatic recycling of C++ handles (if you don't know what this means and why it's important, you need to be using OpenNTF Domino API!)
  • Standard iterators for all appropriate Domino Object Model classes
  • Fixes to make development more standard for Java developers
  • Modernisation of some Java classes returned
  • Enums to make code more readable and avoid typos
  • More flexible interaction with data stored in Documents
  • In-built error logging using XPages OpenLog Logger
  • Transactional processing
  • Multi-threaded processing in background or dynamic (Xots)
  • Scheduled multi-threaded processing (coming in ODA 2.5.0)
  • Event Listeners
  • Improved access to databases and documents
  • Graph database storage on top of Domino

CrossWorlds allows you to use a modern Java EE web server instead of Domino's HTTP server. This means servlets coded to Servlet 3.0 specification and standard web applications, without the need to wrap the application in a plugin. It also means being able to leverage Java 1.8, which is currently not available in Domino 9.0.1.  But you still have access to everything else that's useful. Native access.

Think of it like preferring to store your data in a SQL database rather than an NSF, and using JDBC access to the data from XPages. Or like the recent work on adding a node.js or vert.x engine on top of Domino. You're swapping out one element of the stack, but still able to leverage the rest of the stack. With CrossWorlds, you're replacing the HTTP server with a newer flavour, but keeping everything else - including years worth of critical data. And why pay to migrate that data when you don't have to (and the business don't have time to review it!)