Open source, Apache 2.0. Write the screens in Java, C# or Python, or as YAML, and Mateu renders forms, CRUDs, wizards, dashboards and the whole app shell on the web, the phone, the desktop and inside Oracle Visual Builder.
Most business applications end up as two applications. There is the backend, with the model, the rules and the validation. Then there is the frontend, which repeats the model, repeats the validation and adds a build, a framework and a second team to keep it alive. For a back office with forty screens, that second application is most of the work.
Mateu removes it. You declare what a screen contains, its fields, rules and actions, and Mateu derives the screen. Version 3.0.0 was released on 15 November 2026 and is now the latest release on GitHub. It is the first release with a stable public API.
Mateu in three minutes:
What it looks like
A record, and a class that says "this is a CRUD over it":
public record Product( @EditableOnlyWhenCreating @NotEmpty String id, @NotEmpty String name, @Min(0) @Stereotype(FieldStereotype.money) double price, @NotNull ProductStatus status) implements Identifiable { @Override public String toString() { return name != null && !name.isBlank() ? name : "New product"; } } @Title("Products") public class Products extends AutoCrud<Product> { @Override public CrudStore<Product> store() { return ProductStore.INSTANCE; } } ProductStore is your data access, an implementation of the CrudStore<Product> interface (in-memory in the starter, your database in a real app). Add one field to the app shell, @Menu Products products;, and you have:
- a listing at
/productswith a search box, filters, sorting and paging; - a create form at
/products/new, a record page at/products/{id}and an editor at/products/{id}/edit; - validation from the Bean Validation annotations, in the browser while the user types and again on the server before anything is saved;
- delete with selection, an app shell with its menu, and deep links that work on reload.
There is no frontend code in the project. Episode 2 of the video series goes from a record to a full CRUD step by step.
AutoCrud is one of several archetypes. A class that extends Wizard becomes a multi-step process, Dashboard turns MetricCard fields into a KPI band and @Panel fields into tiles, and Welcome, ItemOverview, Foldout, CollectionDetail, CalendarPage and others cover the rest of a back office. When an archetype does not fit, you build the screen from components yourself.
The same in C#, Python, or no code at all
Mateu has three server implementations that speak the same wire protocol: Java, C# on ASP.NET Core and Python on FastAPI. The C# and Python versions of the screen above are a Crud<Product> class with four small methods (fetch, get, save, delete). A shared conformance corpus of screens holds the three to the same JSON, so a renderer cannot tell which language is behind it. Episode 6 shows the three side by side.
You can also skip code entirely. A screen can be data, in a YAML file under specs/ui:
type: Listing title: Products searchable: true rowsSource: ref: products # an endpoint named once in sources.yaml columns: - {type: GridColumn, id: name, label: Name, sortable: true} - {type: GridColumn, id: price, label: Price, stereotype: money, sortable: true} - {type: GridColumn, id: status, label: Status, dataType: status, sortable: true} The products source can carry sample rows, so a UI works before its API exists. The YAML can be written by hand or by the visual editor that ships with the Mateu plugins for IntelliJ and VS Code. It can be served by a Spring Boot app, or exported as a static bundle and put on a CDN with no backend at all; the bundle calls your REST APIs directly from the browser. The public museums demo is written this way: every screen is YAML. Episode 3 builds one from scratch.
One declaration, several places to run it
The declaration says what the screen is; each renderer decides how to draw it. With 3.0 the same screen runs:
- on the web, with Vaadin components or with Oracle Redwood (JET and Spectra, loaded from Oracle's CDN);
- in the Mateu phone app for iOS (on the App Store) and Android;
- in the Mateu desktop app for macOS, Windows and Linux;
- inside your own Oracle Visual Builder app, with one element:
<mateu-ui>. I wrote about that one separately: One element, a whole app: Mateu inside Oracle Visual Builder; - for AI agents, over MCP (more on that below).
Here is the same record page of the museums demo, drawn by the Vaadin renderer and by the Redwood renderer, from the same YAML and the same server:
The phone and desktop apps work like a browser for Mateu UIs: you add a UI by its address or a QR code, and its screens draw as native controls. If you need your own branded app instead, both can be built bound to a single UI. Episode 4 shows one screen on every surface, and episode 13 shows it inside Visual Builder.
Page templates, after Oracle Redwood
Oracle's Redwood design system describes a set of page templates for business apps, and Mateu follows them: welcome page, dashboard, hero search, smart search, collection-detail, general overview, item overview, foldout, guided process, calendar, to-do list, data management and more. In Java you get them by extending an archetype or annotating a page; in YAML a form names its template:. On the Redwood renderer they become Oracle's own Spectra templates; on the other renderers, Mateu's version of the same layout.
You can browse every archetype, template and component, live, in the Mateu Explorer. Episode 5 walks through the templates.
Backends you already run
On the Java side Mateu has adapters for Spring MVC, Spring WebFlux, Quarkus, Micronaut and Helidon MP. An annotation processor generates the controllers at compile time, and the @UI classes themselves can live in a module that depends only on Mateu's API jar, with no framework in it. Every adapter runs the same parity test suite. On .NET it is an ASP.NET Core package, on Python a FastAPI one.
AI agents, when you switch them on
Each Mateu app can expose an MCP server. It is off unless you enable it. When it is on, an agent can list the screens, read them, fill fields and run actions under the same identity and access rules as a user, and it can also write new screens as YAML: the server validates and previews them, and saves them only in development mode. A second, separate switch lets a user pair one open browser tab with an agent, so the agent can push a screen to that tab and to nothing else. The desktop app has its own MCP server for the window that is open, also off by default.
Secure and boring in production
Mateu does not authenticate anyone: the caller is whoever your framework (Spring Security, Quarkus, ASP.NET Core and so on) says it is. What Mateu does with that identity is strict by default:
- an action runs only if the screen declared it; anything else is refused;
- fields a user may not see are left out of what the server sends, and fields they may not change are dropped from what it accepts;
- CRUD writes are checked on the server, not only hidden in the UI;
- CORS and MCP are off until you configure them;
- an unexpected error shows the user a reference number, never a stack trace, and the details go to your log under that number.
Episode 7 covers identity and permissions. For day-to-day robustness, the web renderers handle slow and dropped connections (busy controls, safe retries of reads, a clear message instead of a dead screen), the phone app has an experimental offline queue for actions that can wait, there is an accessibility conformance report against WCAG 2.2 in the docs, requests produce OpenTelemetry spans and metrics, and a user on an old tab after a deploy gets a "this app has been updated" notice instead of a confusing error.
Where Mateu fits
Each piece of this exists somewhere else, and some of it is done very well:
- Model-driven UIs from your classes: OpenXava and Jmix turn Java entities into business screens, and Django's admin does it for Python models.
- Low-code platforms: Oracle APEX, Visual Builder, Retool or Appsmith build business apps fast, inside their own tool and platform.
- Server-driven UI: large companies build it in-house so their native apps draw screens described by the server.
- Java-only web UIs: Vaadin lets you build the web UI in Java, component by component.
What Mateu adds is getting all of it from one declaration: written as code in Java, C# or Python or as YAML data; drawn on the web with Vaadin or Oracle Redwood, in native phone and desktop apps and inside Oracle Visual Builder; operable by AI agents under the same rules as a person; deployable as static files when there is no backend. Open source, on the stack you already run.
A stable 3.x
From 3.0.0 on, the public Java API keeps binary compatibility across the 3.x line, and every build checks it. The .NET and Python APIs are pinned by their own tests, and the wire protocol stays compatible within the major version. Features still finding their final shape are marked @Experimental, so you can see what is covered by that promise and what is not.
Getting started
- Java: create a project from IntelliJ (File › New › Project › Mateu), from VS Code (Mateu: New Project…), or with the Maven archetype
io.mateu:mateu-archetype. All three generate from the same starters. Versions come from the BOM,io.mateu:mateu-bom:3.0.0. - C#: the
Mateu.*packages on NuGet, version 3.0.0. - Python:
pip install mateu-ui(3.0.0). - Learn by typing: the repository has a half-day hands-on workshop in
workshop/, with Java, C# and Python tracks, covering renderers, tests, YAML, AI agents and sign-in.
Docs and quickstarts are at mateu.io, the code is at github.com/miguelperezcolom/mateu, and the release notes are at Mateu v3.0.0. Mateu is Apache 2.0.
If you build back offices, try it on one screen you already have and see how much of it is left to write. Issues and questions are welcome on GitHub.
Originally published on Medium.





