Released 10 September 2026
Shipped on 10 September 2026, and the largest release so far. Validation moved into the storage engine and now passes the entire W3C SHACL Core test suite, 98 cases out of 98. Validating the Northwind sample went from six seconds to under one, and a 133-million-triple database now validates in about half an hour, where the run simply never finished before. Queries are planned by cost from real statistics about your data, you can see the plan the engine chose, and every statement is indexed six ways instead of three so joins do far less work. Imports are fast everywhere. Reasoning refreshes your statistics itself, stops leaving stale answers behind, and no longer fails a save that lands while it runs. And you can hand RDF Studio a database schema, data samples, queries, and documents that describe the business process — and get a real model back including the ontology, its validation rules, taxonomies, mappings, competence questions saved as runnable queries, and sample data to try them against.
One caveat before you read on. Reasoning gained real fixes in this release, but not speed: materialization itself is no faster. What it gained is a report of where its time goes, and that measurement is what makes the next step possible — it showed that writing inferred statements back to the store is about 71% of the cost and the rules themselves about 4% — and making it faster is on the roadmap.
The largest piece of work in this release, and the reason it exists. Most of it is computed from your files before any AI is asked anything.
Tables become classes, columns become properties, NOT NULL becomes required, foreign keys become relationships. Every term is marked as either declared by your source or inferred, so you can tell what was read from what was guessed.
Model ▸ GeneratePer kind of constraint, stated in plain words. Where OWL genuinely cannot express something, "describe" is not offered at all rather than silently producing nothing.
Model ▸ Generate ▸ ConstraintsSQL CHECK rules, JSON Schema, Avro and Parquet. Ranges, IN lists, LIKE patterns, length bounds and column-to-column comparisons all carry through. What SHACL cannot express is written onto the shape as a note instead of vanishing — a rule like DOB < today is recorded and marked unenforced.
One mapping per class, including composite keys and join tables. Checked before it is saved, so a mapping naming a column that doesn't exist is reported rather than written. The result is also described as a data product.
Model ▸ Generate ▸ MappingsMark a document as a taxonomy and the classification it describes becomes a proper concept scheme. Links back to your classes and columns are computed and only ever suggested — and a category the document never actually defines is flagged rather than invented.
Model ▸ Generate ▸ Read as ▸ TaxonomyA description like "Soft drinks, coffees, teas, beers, and ales" becomes a parent with its children. Which cells are worth reading is decided by arithmetic, so nothing is spent on a large table of prose.
A product catalogue is both prose and a classification; a schema dump is both structure and a record of the queries people run. "Read as" is now a multi-select, and ignoring a file no longer erases what it is.
The next suggestion becomes a lookup rather than a guess, and is marked as derived rather than inferred. Private to you — nothing is pooled between users.
Monitor ▸ ConventionsA run whose competence questions error or return nothing now stops and names each one, instead of settling quietly into "review" and looking finished.
It was being cut short, and every relationship sat past the cut — so generated test data had no links at all, dates were written as plain text, and generated queries named properties that don't exist. Afterwards: 10 of 10 questions answered where 7 had been, and 31 relationships in the test data where there were none.
Its mappings and its saved question folders go with it. Running twice with the same name asks before replacing, and the name is now checked as you type rather than colliding at the end.
The step showed nothing for minutes and looked stuck. It now counts through the work, and starting a new run warns you what is still in flight.
Measured before and after on the same machine, through the real screens.
Northwind validates in about a second where it took six. On a two-million-triple set, forty seconds where it took nearly ten minutes. Identical findings to the old checker, and it now passes the official W3C test suite completely — a case the old one got wrong.
Model ▸ Shapes ▸ ⋮ ▸ Validate DataYou can leave the screen and come back to it.
Monitor ▸ Activity34 MB in one second where it took nearly three; 86 MB in two and a half where it took eight; 853 MB in seventeen. Uploading a compressed file is now the faster choice, not the slower one. Memory no longer grows with the size of the file.
Configure ▸ Database Settings ▸ Import DataAn import into a graph that already holds data is read through first. If the file is malformed you get the line number and nothing is written.
Reasoning left the query planner working from a picture of the database as it was beforehand. On a large set this turned queries that should take a moment into ones that never finished. The planner is now brought up to date whenever the data changes shape.
Inferred triples used to stay invisible until you refreshed the statistics by hand. Now every reasoning operation that changes triples — materializing, running rules, clearing inferred — updates the counts on its own, and a long refresh can be followed while it runs.
Monitor ▸ ActivityAdd an order and re-run reasoning: the customer stops being listed as having no orders, and product counts stop accumulating two different values. Your own data is never touched — only what reasoning previously concluded.
It used to fail with an error. The save now goes through, and reasoning catches up afterwards. The card says it is temporarily out of date, and why.
And it says what it produced, instead of appearing to do nothing. When reasoning does fall short, the message now names the real cause — a memory limit, an error — instead of blaming a time limit that may not even be set.
Measurement only — nothing was made faster yet. What it shows is that rule evaluation is a small share of the cost and the bulk is writing results back, which redirects the optimisation work that follows.
Every class, property, column, pill and title in Browse and Traverse is named the same way: the label your ontology gives it first, qualified only when two things would otherwise read identically. One Label / Local / IRI control in the Explore header drives all of it, remembered per database.
Explore ▸ NamesProperties showed raw identifiers where the ontology plainly says "Categoria" — an invented label was outranking the real one at render time while the sort order read the real one. Nothing invents labels any more, and databases already carrying them heal on their own.
It reported 154 triples and showed classes that were RDF Studio's own bookkeeping, not yours. The card count and the Browse list also disagreed with each other; they now agree.
Counts are only recalculated when you ask, so a fix to what a number means would otherwise never have arrived. Databases created before the change are now marked out of date, and one refresh brings them current.
An empty sidebar is indistinguishable from a failure, so it now says which ontologies you chose and why nothing came back — for example that an ontology declares eleven classes but none of them have data here.
Explore ▸ BrowseClasses from other ontologies no longer appear when you have filtered to one — including classes an ontology only mentions as a parent. Only classes that no ontology declares stay visible, and the legend says so.
They reverted to raw property names after a statistics refresh.
Browse showed a blank table. It now explains that those entries cannot be opened individually, rather than looking broken.
Values keep their proper type when saved; warnings hold the dialog open so you can read them; names reject digits where the shapes say they should; an edit follows the instance into its own graph; and the edit dialog opens on the instance's own fields instead of every field its types allow.
A mapping holds many sources, chosen or created inside the form. Mappings from a generated run arrive ready to be bound to whichever source holds the full data.
Integrate ▸ MappingsA virtualized mapping is never loaded. It is published to agents as a description of where the data lives, and the agent brings its own credentials.
Export and import are both available; a file from another tool is refused with a reason rather than half-read.
Integrate ▸ Mappings ▸ ⋮ ▸ Edit R2RMLIt names each field instead. And the field list now scrolls, so a mapping with many columns is fully reachable.
Mostly invisible when right, and the source of several confusing failures when wrong.
Creating a database now starts from your ontology and data files. The three addresses that matter — the base, the ontology's namespace and the data's — are each proposed from what the files actually declare, shown with where each suggestion was read from, and confirmed by you before any prefix is generated. The confirmed rows then appear in the prefix table read-only, so there is one editable source and a complete list.
Connect ▸ Create ▸ Configure NamespacesA file that models and populates in the same namespace used to get two prefixes for one address, and which one you saw came down to load order. It gets one prefix now, with a chip for each role it plays — ontology and data both — and the same address always renders the same way.
The wizard and Database Settings wrote the namespaces file through two different routes, which drifted three times in one afternoon — duplicates merged by one and kept by the other, comments preserved by one and wiped by the other. There is one writer now; the settings screen uses it too.
Configure ▸ Database Settings ▸ NamespacesA freshly created database rendered with whatever prefixes were cached before it existed, so the editor showed a bare colon where your prefix belonged, and the graphs list spelled out full addresses the database has names for.
Northwind's saved queries were pointed at a different address from the one its data uses. Affected the sample's own query library and Music's.
Query ▸ LibraryIt was saved and then ignored, for two separate reasons — the database could end up with two namespace files and reads took the wrong one, and the old name survived alongside the new one. Saving now also confirms what changed.
Configure ▸ Database Settings ▸ NamespacesSaving a prefix used to rewrite the whole file, replacing everything explanatory with a generated header. Edits are now made in place, and a renamed prefix keeps the comment that describes it.
The wizard used to prefill a made-up address. It now proposes one from what your data actually uses, with the reason — and proposes nothing when your data has no single home, rather than guessing.
One confusion produced five different-looking failures: reasoning reporting no ontology over a real one, queries returning nothing, a prefix covering a fraction of the data. Imported content lives where the file put it, and the app now looks there.
Which graph holds your data and which holds your model is now part of the data itself, so it survives being exported and loaded somewhere else.
Configure ▸ Database Settings ▸ Named GraphsOptional, per file, on both import screens, with a custom address if you want one.
Northwind, from source files: the artifacts it was built from, the ontology derived from them, shapes, mappings, questions, data, and the record of where each part came from.
Connect ▸ Create ▸ Northwind (generated)Eight steps across four tabs, explaining what to look at and why. It opens by saying the run is already finished and nothing needs re-running.
One character in one file. Every shipped file is now checked by a test that loads it the way the app does.
One database created from a removed template turned a list of seventeen into nothing at all. Retired templates now simply lose their label.
And a sample installed under a different name no longer splits in two and reports validation as clean over nothing.
The stepper offered five steps and stopped after the fourth, so Import Data could never be reached on that path. The flow now walks through to the end.
It shipped to everyone and was the most elaborate one offered, yet none of its own ontologies had a single class with data — so a first exploratory click returned an empty panel.
Left over, linked from nowhere.
The browser's password manager no longer covers credential fields. Cards open on click instead of needing the ⋮ menu. Long addresses use the width available instead of being cut short. Run history rows have room to breathe. Visualize always draws the entity you asked for. Empty screens say what is actually going on rather than offering actions that cannot work. The Type control looks like the multi-select it is, fits two role pills side by side, and the column that lists IRIs is headed IRI. Reasoning messages stay on screen until you dismiss them instead of vanishing after eight seconds.