Tentackle is an Open-Source Java framework for tiered applications running on multiple JVMs, inspired by the principals of Domain-Driven Design. It features a remoting-capable variant of the Persistent Domain Object pattern, providing a clean separation between the domain- and the persistence-layer with no dependencies to each other. In fact, entities are just interfaces. Their implementations for both the domain- and the persistence-logic are injected at runtime. Entities travel between JVMs while keeping their domain- and persistence-context. As a result, any method of an entity can be invoked, at any time, in any JVM, independent of the entity’s physical origin. The domain model is specified right within the source code and picked up by code generators via a model-API at build-time.

Originally Tentackle has been developed for scientific and technical applications, where running the same domain logic not only in intermediate tiers but also at remote sites very often is an irrevocable requirement. However, business applications can benefit from its architecture as well, especially multi-tier Java FX desktop applications.

Jump Start

The easiest way to get your first application up and running is to use Tentackle’s maven archetype. Please follow the steps described here.


As always, the code is the truth, but sometimes it’s nice to have some more in-depth documentation available.


A step by step introduction explaining the concepts, ideas and solutions provided by the Tentackle framework. Learn how to define your domain model, generate the implementations, develop the UI, modularize the application, test your code and much more.


Facts for the impatient.

The Persistent Domain Object

A persistent domain object (PDO) combines persistence- and domain-related features. However, Tentackle PDOs are not ordinary POJOs but POJIs: Plain Old Java Interfaces.
The PDO’s interface extends a persistence- and a domain-interface, that are implemented separately without any dependency to each other. This design brings the best of both worlds, the rich and the anemic domain model: implement the domain- and persistence logic within the same OO hierarchy, but keep them strictly separated!



Distributed by design

Since entities and operations travel freely between JVMs, the ubiquitous language is available in all tiers.


JPMS Modularity

Tentackle is a modular framework from the ground up leveraging the features introduced with Java 9 (Jigsaw).



Applications are developed against interfaces, not implementations. Especially the precious domain logic does not depend on the persistence implementation.


Maven Plugins and Wizards

Tentackle provides several maven plugins to ease the development process. PDO and Operation wizards create the interfaces and implementations within the blink of an eye.


JLink images

Tentackle’s maven jlink plugin creates self-contained Java applications. No need for system-wide Java installations anymore. The plugin can be used for any kind of java application, not only Tentackle apps, even non-modularized or mixed.


Model driven

The domain model is defined in comment blocks right within the sources. During the maven build the model is parsed and the source code generated or updated accordingly.


No bytecode voodoo

There is no bytecode instrumentation and no classpath scanning. All necessary steps to analyze the application are performed at build time, thus reducing the startup time significantly.



Tentackle provides an auto-update feature. Once installed the application automatically updates itself whenever a new version becomes available.


Immutable objects

PDOs can be immutable. For example, a component PDO not loaded from within its aggregate root’s domain context is automatically immutable.



Snapshots of entities, aggregates or parts of them provide a kind of “transactions in memory”. With snapshots it’s very easy to implement undo operations, for example.


Tentackle has been successfully used in many projects, mainly technical and scientific applications. During the years it has gone through several redesigns and major refactorings. Eventually, it became Open Source for “those who were interested”. Since 2016 the sources are hosted at Bitbucket and the artifacts are available from Maven Central. Finally, in 2020 we felt that Tentackle has reached a level of maturity, usability and well working tooling to introduce it to a broader public.