[opensourcedex]

Structr is a free, open source frameworks & platforms project written in Java and released under a custom open-source licence. It has 830 GitHub stars, 161 forks and 5 open issues, and was last pushed 8 days ago. On this registry it ranks #25 of 28 tracked projects in Frameworks & Platforms, with 5 head-to-head comparisons available. It gained 1 stars over the last 6 tracked days.

What is Structr?

Structr is an open-source, generic low-code development and runtime platform built on a graph database, aimed at developers and teams who need to model, build, and operate fully custom applications rather than configure a prebuilt product.

What it is

Structr is a Java application platform that stores both its application components and application data in a graph database, with Neo4j named as the database in the README and GraalVM JDK 25 as the runtime. It separates application development from application usage through two web-based interfaces: a Developer and Administration UI that acts as an integrated development environment, and the end-user application UI that developers build with it. The Admin UI is where the application graph is modified, and that graph holds the part of the database which defines the application. Development therefore does not happen in a raw source code tree; it happens by editing schemas, types, properties and relationships, isolated script expressions and methods, HTML templates and UI definitions, virtual files with custom metadata, and configuration and operational settings.

The concrete problem it addresses is the split between how an application is defined and how its data is stored. In Structr, both live in the same graph, which the README frames as providing schema flexibility, fast graph traversals, and expressive data modeling without join-heavy queries. Rather than maintaining a separate application source tree alongside a relational schema and an access layer, a developer edits high-level artifacts held in the graph through the browser-based IDE. The platform deliberately positions itself against prebuilt business applications such as CMS, CRM and ERP systems, and against fixed-purpose frameworks with predefined domain logic, website builders with limited customization, and template collections tied to specific industries.

Key capabilities

  • Graph-backed application definition: schema, UI definitions, templates, scripts and workflows are stored in the same graph as application and user data.
  • Web-based Developer and Administration UI that functions as an IDE, exposing modeling, configuration, extension and operation tools for the application graph.
  • Polyglot scripting through GraalVM, so any language supported by GraalVM can be used for scripts and methods.
  • Database schema represented as JSON Schema, with import and export supported against the JSON Schema format.
  • An internal virtual filesystem for files and binary content with custom metadata, with binary data optionally stored on external file storage providers such as S3.
  • REST/JSON API access, with OpenAPI listed among the project topics.
  • Event-driven integration alongside file access over FTP and SSH/SCP, and MCP enabled for AI integration.

Who uses it and how

  • Backend and full-stack teams building custom web applications and data-centric backends, where schema shape is defined in the graph rather than in a fixed domain model.
  • Integration and middleware developers, using the event-driven integration support together with FTP and SSH/SCP file access to move data between systems.
  • Teams running platform-as-a-service style deployments, using the published Docker image; the project advertises GDPR compliance and EU/Germany hosting.
  • Data modeling practitioners who need to import or export schema as JSON Schema, or who benefit from graph traversal instead of join-heavy queries.
  • Java shops already standardized on GraalVM, since the platform targets GraalVM JDK 25 and exposes polyglot scripting as a first-class feature.

Getting started

The README points to the published Docker image structr/structr, and https://structr.org is the project homepage for further detail. The README does not spell out a step-by-step install or compose procedure, so the Docker image and homepage are the starting points it actually names.

How it compares

The facts provided do not name any similar tools, so there is nothing in this registry to compare Structr against on licence, self-hosting, data ownership or cost model. It stands alone in this registry in that respect.

When to use it — and when not to

A self-hoster must run a graph database using Neo4j and decide where binary content lives, either in the internal virtual filesystem or on an external provider such as S3. Structr is the wrong choice for anyone who wants a finished CMS, CRM or ERP, or a fixed-purpose framework with domain logic already written. Two limitations are worth noting before committing: the registry metadata reports the licence as NOASSERTION even though the README badge states AGPL v3 / GPL v3, so the terms should be verified directly, and the GitHub repository is explicitly a clone with development and issue tracking moved to gitlab.structr.com, so the GitHub issue tracker is not the active project channel.

project readme (upstream, from github) — read inline

Structr

pipeline status Hits-of-Code Docker Pulls publiccode.yml

License: AGPL v3 / GPL v3 Java Graph DB Low Code Polyglot REST API JSON%20Schema Event Driven FTP SSH AI Ready GDPR EU Based

Overview

Structr is an open source generic low-code development and runtime platform built on graph technology. It is not limited to any predefined use case and supports the creation of fully custom applications — including web applications, graph-database-backed backends, data-centric systems, middleware, and integration components.

At its core, Structr uses a graph database to store both application components (schema, UI definitions, templates, scripts, workflows) and application/user data. This provides schema flexibility, fast graph traversals, and expressive data modeling without join-heavy queries.

Structr supports representing its database schema as JSON Schema, including import/export (see https://json-schema.org).

Structr includes an internal virtual filesystem for managing files and binary content with custom metadata. Binary data can be stored externally on file storage providers (e.g., S3).

What Structr is not

To set clear expectations, Structr is not:

  • A prebuilt business application (e.g., CMS, CRM, ERP)
  • A fixed-purpose framework with predefined domain logic
  • A website builder with limited customization options
  • A collection of templates tied to a specific industry
  • A replacement for general-purpose programming languages

Instead, Structr is a generic application platform providing the building blocks, abstractions, and runtime needed to design, build, and operate your own applications within a controlled and extensible environment.

Frontends and Development Model

Structr separates application development from application usage through two different web-based user interfaces.

Structr Developer / Admin UI (IDE)

Structr provides a web-based Developer and Administration UI that acts as an integrated development environment (IDE). It exposes the platform’s capabilities through structured tools for modeling, configuration, extension, and operation of applications defined in the graph.

The Admin UI is used to modify the application graph: the part of the database that defines the application.

As a Structr developer, you typically do not create or edit a raw source code tree for your app. Instead, development happens by editing high-level artifacts stored in the graph, such as:

  • schemas, types, properties and relationships
  • isolated script expressions and methods
  • HTML templates and UI definitions
  • virtual files with custom metadata
  • configuration and operational settings

Structr supports polyglot scripting via GraalVM — i.e., you can use any language supported by GraalVM for scripts and methods.

End-User Application UI (Built with Structr)

Using the tools of the Structr IDE, developers create an end-user facing web UI that is served directly by Structr. Pages, templates, bindings, and workflows are defined in the graph and can be evolved at runtime.

Developer & Admin Tools

Structr provides a comprehensive, web-based Developer and Administration UI that exposes the platform’s core capabilities through structured tools. These tools are used to design, configure, extend, and operate applications defined in the graph database.

Platform & Operations

  • Dashboard with system information and runtime status
  • Server log and event log viewer
  • Thread and job queue inspection
  • Deployment and environment information
  • UI configuration and settings

Schema & Data Modeling

  • Graph-based schema editor
  • Type, property, and relationship management
  • Function properties with read/write scripting
  • Runtime schema evolution
  • Virtual types management

Data Management

  • Graph-aware data browser and editor
  • Spreadsheet-style CRUD editing
  • Relationship linking and navigation
  • Bulk data import (e.g. CSV)

Page & UI Development

  • Page and template editor
  • Drag-and-drop UI components
  • Dynamic repeaters bound to graph queries
  • Templating expressions and localization
  • Live preview of end-user pages

Application Logic & Code

  • Script editor for user-defined functions and methods
  • Polyglot scripting via GraalVM
  • Runtime execution and result inspection
  • OpenAPI exposure configuration for types and methods

Files & Assets

  • Virtual filesystem browser
  • Folder and file management
  • Custom metadata for files and folders
  • Binary files (images, videos, arbitrary content) with optional external storage (e.g. S3)
  • Dynamic virtual files generated in real time via scripts
  • File access via HTTP, FTP, and SSH/SCP (depending on deployment/configuration)
  • Integration with background jobs (e.g. CSV imports)

Graph Exploration

  • Visual graph browser
  • Cypher query execution
  • Interactive node and relationship inspection

Workflows & Automation

  • Flow editor for orchestration logic
  • Node-based workflow modeling
  • Execution and result inspection

Security & Access Control

  • User and group management
  • Role-based and resource-based permissions
  • REST API access control
  • CORS configuration

Localization & Communication

  • Localization key and translation management
  • Mail template management

AI, LLMs, and Low-Code as Guardrails

Structr’s combination of no-code, low-code, and pro-code tools makes it a strong foundation for AI- and LLM-assisted application development.

Instead of allowing AI systems to generate unconstrained source code, Structr limits interaction to explicit schemas, structured tools, isolated scripts, and well-defined APIs.

This means:

  • AI operates within well-defined boundaries
  • Changes are applied through structured models and tools
  • Errors and unintended side effects are reduced

In this sense, low-code provides guardrails for AI. Structr allows AI systems to assist in designing, extending, and operating applications while keeping full control over structure, behavior, and security.

Structr can be used with AI to create apps and interact with the Structr application and the data it manages through MCP (Model Context Protocol).

Architecture

  • Java-based backend with a web frontend (admin IDE and end-user UI)
  • Runtime: GraalVM JDK 25
  • Graph database: Neo4j 4.4+ (including 5.x and 2025.x)
  • Monolithic core with modular/extensible design
  • REST/JSON APIs for integration
  • Virtual filesystem with custom metadata and optional external binary storage (S3)
  • Optional containerized deployments (Docker/Podman), Kubernetes orchestration

Structr instances can be operated as small services that interact via REST APIs or through event-driven / pub-sub protocols.

Integration & Interoperability

  • REST / JSON APIs
  • JSON Schema import/export for schema representation
  • Pub/sub and messaging: AMQP (RabbitMQ), Kafka, Pulsar, XMPP
  • Email: SMTP (outbound), IMAP
  • Identity & SSO: OAuth providers, LDAP-compatible services
  • File access: HTTP, FTP, SSH / SCP
  • Storage: S3-compatible repositories
  • AI integration: MCP

Licensing

Structr is dual-licensed:

  • Open Source: GNU AGPL v3 or later and GNU GPL v3 or later
  • Commercial / Individual License: available from Structr GmbH

See LICENSE.md and COPYING.txt for details.

Security

Security policy and supported versions are documented in SECURITY.md.

Contributing

Questions and general discussions should go to the forum first:

See CONTRIBUTING.md for de

readme truncated — read the full docs on github

Frequently asked questions

Is Structr free to use?

Structr is open source. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Structr do?

Build complete web apps with integrated graph database

What is Structr written in?

Structr is primarily written in Java. Its source is publicly available at https://github.com/structr/structr, and it has 830 GitHub stars.