microsoft/Ontology-Playground: a static RDF editor and catalogue for Fabric IQ

What Ontology Playground is for, and who it is aimed at

Ontologies are usually explained with diagrams on slides and edited in tools that assume you already know what an object property is. Ontology Playground sits in the gap between those two. The README describes it as a free, open-source web application for learning about ontologies and Microsoft Fabric IQ, and the feature list is organised around that teaching goal: a catalogue of pre-built ontologies, a visual designer, an Ontology School with nine courses, five quests with progress bars, and a natural language query playground that shows how a question like "Which customers placed orders?" maps onto entities and relationships. The last item is explicitly framed as a preview of Fabric IQ's NL2Ontology capability, so the app is also a way to see what Microsoft's ontology layer is supposed to do before you commit a Fabric workspace to it.

The audience is therefore narrower than "anyone doing knowledge graphs". It suits a data engineer who has been asked to model a retail or clinical domain for Fabric IQ and wants a fast visual first pass, a trainer who needs shareable diagrams and quizzes, or a developer who wants to embed a read-only ontology viewer in documentation. It does not suit someone who needs to query or reason over production data; nothing in the README describes a query endpoint or an inference engine.

Cytoscape.js, Zustand and a build step that compiles the catalogue

The architecture is deliberately shallow. There is no server component: the README states the app is fully static with zero backend dependencies, and the repository layout confirms it, with src/, public/, catalogue/, content/ and a set of scripts/ that run at build time. Graphs are rendered with Cytoscape.js (the fcose layout extension is a dependency), UI state is held in Zustand, and routing is client-side hash routing, which is why every ontology has a deep link of the form /#/catalogue/official/cosmic-coffee.

The interesting part is what happens before the bundle is produced. The build script is a chain:

npm run catalogue:build && npm run learn:build && tsc -b && vite build && npm run build:embed

catalogue:build runs scripts/compile-catalogue.ts and learn:build runs scripts/compile-learn.ts, so ontologies and lesson markdown are compiled into the app rather than fetched at runtime. A separate Vite config, vite.config.embed.ts, produces the standalone ontology-embed.js widget. That design explains both the strengths and the limits: content is fast and offline-friendly, but adding an ontology means changing files in the repository and rebuilding, not uploading through an admin interface. The one-click catalogue PR flow is the intended path for contributions, and it uses GitHub device flow to fork the repo, create a branch, commit the RDF plus metadata, and open a pull request.

Installing Ontology Playground locally and opening the designer

The README lists Node.js 18+ and npm 9+ as prerequisites. The repository is a standard Vite project, so the install is two commands from inside the cloned directory:

cd Ontology-Playground
npm install
npm run dev

The README says to visit http://localhost:5173 after npm run dev. You should see the home page with the default ontology rendered as a node-and-edge graph; the command palette opens with Ctrl+K or Cmd+K, and the header links lead to the Catalogue, Designer, Ontology School and Import/Export.

For a first real use, open the designer and start from a template rather than a blank canvas. The README states the designer offers five domain templates (Retail, Healthcare, Finance, IoT, Education), each creating 3 entities with properties and 2 relationships. Once you have edited an entity, the live graph preview updates as you work, and undo/redo is capped at 50 levels. To check what you will actually ship, run the validation script and the test suite:

npm run validate
npm test

npm run validate invokes scripts/validate-rdf.ts, and npm test runs Vitest once (npm run test:watch keeps it running). The README also mentions automated round-trip tests for RDF fidelity, which is the part worth trusting least until you have tried it on your own file.

RDF/XML round-trip is the real constraint, not the drawing

The README claims full round-trip support for RDF/XML covering OWL classes, datatype properties, and object properties with cardinalities, and says the export matches the format Microsoft Fabric IQ expects. That claim is the load-bearing one for anyone using the tool seriously, and it is also the claim a reader should verify first. The README does not enumerate which OWL constructs are preserved: there is no list of supported restrictions, no statement about annotations, imports, individuals or datatypes beyond the general description, and no documented behaviour for constructs the designer cannot represent. A visual editor that models entities, properties and cardinalities is a subset of OWL, so anything outside that subset is where fidelity will break.

The other constraint is scale. The official ontologies in the README range from 5 to 6 entities and 5 to 7 relationships, and the largest example in the learning material is a 15-entity retail supply chain ontology built across a seven-step lab. Cytoscape.js will draw larger graphs, but the README documents no performance guidance, no clustering or filtering strategy for hundreds of nodes, and no way to collapse subtrees. If your domain model has several hundred classes, the visual editor is the wrong surface for it.

Where the static, zero-backend design becomes a limitation

Zero backend is a genuine advantage for distribution: the app deploys as static files and the embed widget is a single script tag, so an ontology diagram can live in a wiki or a documentation site without a service to operate. The same choice removes capabilities that ontology tools are often bought for. There is no server-side store, so there is no shared editing session, no history beyond the 50-level undo stack in the browser, and no access control on the catalogue beyond the GitHub pull request review that gates contributions. The README does not document rollback, versioning of catalogue entries, or what happens when two people edit the same ontology concurrently, because the model is one person editing locally and opening a PR.

There is also no reasoner and no query interface. The natural language query playground maps questions to entities and relationships as a demonstration; it is not a SPARQL endpoint, and the README does not claim it executes queries against data. Teams that need entailment, consistency checking, or federated queries are looking at a different class of software, and the app's own framing (learning, preview, playground) is consistent with that.

Ontology Playground compared with WebProtégé and Protégé

The obvious comparison is Protégé and its web counterpart WebProtégé, which are the long-standing open-source ontology editors. The difference is in the deployment model and the target user. Protégé desktop and WebProtégé are built around OWL in full, with reasoner integration and, in the web case, collaborative editing backed by a server. Ontology Playground inverts that: it is a static site with no backend, it models a deliberately smaller subset (entities, typed properties, relationships with cardinalities), and it optimises for the first hour of learning rather than the tenth month of maintenance. It also ships things Protégé does not: an Ontology School with nine courses, quests, a command palette, an onboarding tour and an embeddable viewer widget.

The trade-off is explicit. If you need OWL DL reasoning, imports across modules, or multi-user governance, the Protégé family is the closer fit and Ontology Playground will feel like a toy. If you need to explain what an ontology is to a room of analysts, or produce a Fabric IQ-shaped RDF/XML file and a shareable diagram in an afternoon, the static app removes the install and the server entirely.

Licence, maintenance and what an upgrade costs

The repository is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That matters here because the app is designed to be forked and deployed: nothing in the licence prevents you from hosting build/ under your own domain or shipping ontology-embed.js inside a commercial product. The README does not discuss trademark use of the Microsoft or Fabric names, and this is not legal advice; if you rebrand a fork, treat the name and logo question as separate from the MIT grant.

Maintenance is a real consideration rather than a formality. The last push to the default branch was on 2026-09-17, so the project is recent but the README carries no release history and no versioned changelog, and package.json still declares version 0.0.0 with the title "Preview". Upgrading means tracking the repository: React 19, TypeScript 5, Vite and the Cytoscape stack all move, and because the build compiles catalogue and learning content through custom scripts, a breaking change in those scripts affects your content as well as your code. The repository ships .githooks/, a gitleaks configuration and a security:setup script, which suggests the maintainers expect contributors to run local checks; a fork that ignores them inherits the maintenance burden without the tooling.

Editorial conclusion

Ontology Playground fits engineers, analysts and data modellers who need to sketch a Fabric IQ ontology, teach RDF/OWL concepts, or embed a read-only graph in a page, and who can live with a client-side editor and no reasoner. Teams that need inference, SPARQL querying over a live endpoint, or a governed multi-user repository should not treat it as a replacement for a triplestore plus an editor such as WebProtégé. Before adopting it, check three things in the repository itself: that the RDF/XML your domain needs survives a round trip through the designer, that the build pipeline (npm run build) passes against your Node version, and that the deploy target you want is covered by the shipped Azure Static Web Apps workflow or by hosting build/ as plain static files.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. microsoft/Ontology-Playground on GitHub
4. README