BESSER

This BESSER review covers what the BESSER low-code platform is used for, its key features, what it costs, the B-UML modeling language, where it shines and falls short, and how it compares with other low-code tools. BESSER (Building bEtter Smart Software fastER) is a "low-modeling, low-code" platform: you describe your application as a model, then code generators turn the model into a backend, a database schema, a web or mobile frontend, or an AI agent. It is written in Python, released under the MIT license, and developed by the Luxembourg Institute of Science and Technology (LIST) with the University of Luxembourg, funded by an FNR Pearl grant. The project moves fast: version 7.18.0 was released on GitHub in September 2026.

What is BESSER used for?

BESSER is used to model a software system once and generate the code for it. A typical project starts with a structural B-UML model (classes, attributes, associations) and generates a Django web application, a REST API with a SQL database, SQLAlchemy or Pydantic classes, or a full web app with a React frontend and a Python backend. The same model can drive a Flutter mobile application, a Java or Spring Boot backend, a JSON Schema or an RDF vocabulary.

The platform aims at "smart" software: applications with AI components. You can model a chatbot or agent and generate it for the BESSER Agentic Framework, model a neural network and generate PyTorch or TensorFlow code, or model a quantum circuit and generate Qiskit code. Researchers use BESSER for model-driven engineering and AI-assisted modeling; development teams use it to generate the repetitive parts of an application stack and keep the model as the single description of the system.

Key features

• B-UML: BESSER's Python-based take on a "Universal Modeling Language", inspired by UML but not strictly compliant, so you activate only the sublanguages a project needs.
• Many model types: structural, object, GUI, state machine, agent, BPMN, feature, deployment architecture, neural network and quantum models, plus OCL constraints and user models (B-UML documentation).
• Code generators: Full Web App, Django, Backend, Spring Boot, REST API, Python, Pydantic and Java classes, test cases, Flutter, React, SQL schema, SQLAlchemy, JSON Schema, RDF, Terraform, PyTorch, TensorFlow, Qiskit, the BESSER Agentic Framework and BPMN.
• BESSER Web Modeling Editor: a browser-based diagram editor at editor.besser-pearl.org where you draw B-UML models with drag and drop and run the generators without installing anything.
• Several ways to create a model: write it with the Python API, use a textual grammar (PlantUML-compatible for class and object models), draw it in the web editor, or transform an image, hand-drawn sketch or UI mock-up into a model with AI.
• Agent modeling: design a conversational agent, then chat with it in the editor's live agent simulation, added in v7.18.0 (release notes).
• Open and extensible: MIT-licensed Python code, pip install besser, your own generators and templates, integration with AI coding agents through agent skills, and a Docker setup to run the editor locally.

BESSER pricing

BESSER is free. The platform, the Python library and the generators are open source under the MIT license, and the online BESSER Web Modeling Editor is free to use. There are no plans, seats or usage metrics, and no paid tier listed on the BESSER documentation as of September 2026.

The cost surprise to check is everything around the code. You host and run the generated application yourself, so servers, databases and deployment are your costs. AI-assisted features such as image-to-model transformation call external large language models, so check which provider and API key they need. There is no commercial support contract: help comes from the GitHub issues and the research team, so budget developer time for fixes and for writing your own generator templates when a default does not fit.

B-UML models and the BESSER Web Modeling Editor

B-UML is the heart of the platform. A B-UML model is a set of Python objects that mirror UML concepts: classes with attributes and operations, associations with multiplicities, generalizations, enumerations and constraints written in OCL. Each attribute has a type and can carry a default value; each operation has typed parameters and a return type. Because the model is plain Python, you can inspect it, validate it and save it like any other Python code, and add a description to each element to document the design. You can build the model in code, parse it from PlantUML-style text, or draw it in the BESSER Web Modeling Editor (BESSER WME). The editor stores projects that can hold a class diagram, object diagrams, a GUI model, state machines and agents together, so you can edit every B-UML model of a system in one place, then export and re-import the project.

Because every generator reads the same B-UML model, a change in the model reaches the Django app, the SQL schema and the React frontend in the next generation run. The research team also published a B-UML dataset of 5,410 models in 220 categories, each editable in the web editor with a textual description and Python code, for teams that want examples or data for AI-assisted modeling (Modeling Languages).

From a B-UML model to Python code: an example

Take a small library system, the example the BESSER documentation also uses. In the B-UML model you create three classes, Book, Author and Library. Book gets the attributes title, pages and release date, each with a type; Author gets a name and an email. Associations define the relationships between classes: a Library has many Books, a Book has one or more Authors, and each association end has a name and a multiplicity. Operations carry a description and typed parameters, for example an operation on Library that returns the books of one author. OCL constraints add business rules, such as "pages must be greater than zero", which you can check against object models of real data.

From this one B-UML model, the SQL schema generator writes a table per class, a column per attribute and the foreign keys or link tables for each association, the SQLAlchemy and Pydantic generators write the Python code for the data layer, and the Django or Full Web App generator adds the pages, forms and REST endpoints to create, edit and list records. A GUI model on top decides which page shows which table or form, which links connect the pages and which data each user can access. When the model changes, you regenerate: the implementation follows the model instead of drifting away from it. The generated project is plain code you can store in Git, extend by hand and deploy like any other Django, React or Spring Boot application.

Is UML still used, and why does the BESSER low-code platform build on it?

UML, the Unified Modeling Language, is a standard notation for describing software with diagrams such as class, state machine and sequence diagrams. UML class diagrams are still the most common way to describe data and its relationships, and UML is still used for design, documentation and model-driven development, but many teams find full UML heavy. BESSER takes a pragmatic line: it keeps the parts of UML that generate useful code, adds what UML lacks for modern systems (GUI, agents, neural networks, deployment), and lets you skip the rest. Python instead of the Java-based Eclipse modeling stack makes it easy to combine models with machine learning libraries.

Where BESSER shines — and where it falls short

Strengths:

• Free, open source and MIT-licensed, with no vendor lock-in on the generated code.
• One model generates many targets: web, mobile, database, API and AI components.
• Unusually broad modeling scope, from class diagrams to agents, neural networks and quantum circuits.
• A Python API that fits data science and AI teams.

Trade-offs:

• A research-led project: fast releases, but no commercial support or SLA.
• You need modeling skills; it is a low-code platform for developers, not a no-code app builder.
• Generated applications still need a developer to host, extend and maintain them.
• A smaller community and fewer templates than commercial low-code platforms.

How BESSER compares

• BESSER Bot Framework: the sibling project for chatbots and agents, which BESSER's agent models generate code for.
• Mendix and OutSystems: commercial model-driven low-code platforms with hosting, governance and support, at enterprise prices.
• Oracle APEX: low-code apps on an Oracle database, included with Oracle Database.
• WaveMaker: low-code with generated Angular and Java code you can export.
• Microsoft Power Apps: business apps inside Microsoft 365, for citizen developers rather than modelers.
• FlutterFlow: visual Flutter app builder with code export, focused on the UI.
• Supabase: an open-source Postgres backend when you only need the data layer.

Is BESSER worth it?

BESSER is worth it for developers, architects and researchers who like working with models and want to generate a Python, Java or JavaScript stack from one description, without paying for a commercial platform. It is a strong fit for prototypes, research projects, teaching model-driven engineering and applications with AI components. It is less suited to business users who want a no-code app builder, or to companies that need a supported product with hosting and an SLA; Mendix, OutSystems or Power Apps fit those needs better. If you want help modeling your system in BESSER or turning generated code into a production application, the developers and agencies on LowCodeDevs can take it on.

Sources

• BESSER documentation: the platform, installation, license and funding.
• B-UML language: sublanguages, ways to create models and the list of generators.
• BESSER releases on GitHub: version history, including v7.18.0 and live agent simulation.
• BESSER Web Modeling Editor: the browser-based editor.
• BESSER, a brand new open-source low-code platform, Modeling Languages: the design goals, by the project lead.
• The B-UML Dataset Has Arrived, Modeling Languages: the 5,410-model dataset.