modellwerkstatt werkbank

Model business applications instead of programming them from scratch

modellwerkstatt werkbank (MoWare) is a Java-based toolchain for the rapid development of custom business applications. Three tightly integrated languages describe domain logic, persistence and user interfaces. Generators and runtimes take care of the infrastructure code, you concentrate on the business. The languages are built on top of Java inside JetBrains MPS, so they look and feel familiar to any Java developer.

Short presentation on modellwerkstatt werkbank

Three languages, one model

No additional tools like a separate Java editor or a UI designer are needed. All aspects of a business application are modeled within werkbank.

Business logic

ObjectFlow

org.modellwerkstatt.objectflow

Business data structures, services and commands for application flows. Rules live next to the data, written as Java expressions and set operations. Test suites, roles and permissions included.

Entity
Value Object
DTO
Service
Command

Persistence

ManMap

org.modellwerkstatt.manmap

Mappings between tables and entities. Loading, saving and deleting through repositories, SQL queries directly into read-only DTOs. Object graphs are loaded explicitly: no lazy loading, no magic.

Mapping
Repository
SQL
Read Model

User interface

DataUX

org.modellwerkstatt.dataux

Tables and forms defined by columns, fields, formats and data binding. Layouts, applications with main menu, and batch jobs. Independent of the UI toolkit.

Table
Form
Layout
AppUI
BatchJob

JetBrains MPS with an open PagePane modeled in DataUX

What werkbank delivers

Business first

Data structures and business rules remain the central design task and stay visible in the model.

Expressive logic

Calculations and checks directly on the data, with Java expressions and set operations. UI is CheapCode, the core is ExpensiveCode.

Uniform architecture

Clear responsibilities for data, logic and UI make applications easy to navigate and easy to work on as a team.

Investment security

Models outlive frameworks. Technology is adapted centrally in generators and runtimes, your business knowledge stays untouched.

From model to running application

werkbank generates plain Java from your models. One model targets several runtimes, with few exceptions application models are portable between them:

Desktop: JavaFX rich client, particularly pleasant during development
Web: Vaadin web application on Tomcat, rendered by turkuforms: desktop-style UI with tabs, hotkeys, inline editing, charts, printing, LDAP/OAuth and a compact mode for mobile devices
Mobile: HTML5 on Tomcat for mobile data entry devices (e.g. Zebra, Datalogic) and smartphones
Services: API endpoints as servlets, batch jobs run directly, cron controlled or continuously as servlet

Principles

Business first, technology behind it

The business architecture leads, the technical architecture hides behind it. Domain logic is never woven into frameworks, UI toolkits or database code.

Model, don't wire

An application is a model of entities, commands, processes and screens, not a pile of framework glue. Generators turn the model into plain, readable Java.

Explicit over magic

What is loaded, saved and committed is visible in the model. No lazy loading, no hidden framework behaviour, no surprises in production.

Expensive core, cheap surface

The business core takes domain knowledge, so it is modeled carefully and secured with tests. Screens are cheap and improved in short feedback cycles.

One model, many runtimes

Desktop, web and mobile come from the same model. Technology changes are made once, in generators and runtimes, not in every application.

Two life cycles, built to last

Domain and platform evolve independently, with different people and at different pace. This keeps applications maintainable for decades and counters technical debt.

Ready for coding agents: MoAI

MoAI is the agent plugin for werkbank. It lets coding agents such as Claude Code model business applications directly in JetBrains MPS: through the MPS MCP integration the agent reads model nodes, inserts them from JSON blueprints, validates every changed root and rebuilds the project. No raw MPS XML, no edits in generated code. MoAI bundles agent skills, language documentation and binding modeling conventions for ObjectFlow, ManMap and DataUX.

docu/

4 language documents

moware-werkbank, objectflow, manmap, dataux

Architecture of the werkbank and one document per language. Agents read them in stages: overview and chapter maps for planning, the full text only when a task needs it.

Architecture
Concepts
Chapter maps

conventions/

6 convention files

the MoWare modeling standard

Binding conventions for ubiquitous language, application structure, domain models, commands, user interfaces and tests. A project may adjust single conventions, an agent never deviates on its own.

Language
Structure
Domain
Commands
UI
Tests

skills/

12 skills

moai:objectflow-dsl, moai:manmap-dsl, ...

One skill per werkbank language, a collections skill, and MPS skills for node editing, BaseLanguage, model manipulation, console, language analysis and run configurations.

Rules
Recipes
Examples
Blueprints
Gotchas

MoAI is added to an application project as a Git submodule and installed by the coding agent itself, the instructions in the repository are written as a prompt. How this changes application development is described under spec-driven development with AI.