Re: [ANN] Arspec – an RDF editor where the views are RDF too (try it in the browser)

Hi all,

I wanted to follow up on my email last week about LinkedDataHub 6.

LinkedDataHub renders RDF instance creation and editing forms from
SPIN constructor and SHACL shape definitions, including combinations
of both.
The UI can be seen here: https://www.youtube.com/watch?v=g3i-yH95WZA&t=291s

I agree that validation and entry are different jobs. However I don't
believe RDF is the right layer for describing the forms' presentation
(ordering, widget choice, styling etc.).

That is because LinkedDataHub is essentially an implementation of a
function: Transformation(Projection(Dataset)) (which my book, First
Principles of the Web derives in much more detail:
https://firstprinciplesoftheweb.org/ch07-the-write-side.html#forms-run-backwards).
In this case the projection is a constructed new RDF instance, which
LinkedDataHub transforms into an HTML form using XSLT. That is a
standard W3C data transformation language we have had for decades.
This way content is clearly separated from presentation.

Martynas
atomgraph.com

On Mon, Oct 19, 2026 at 10:05 AM hello@inffront.com <hello@inffront.com> wrote:
>
> Hi Thomas,
>
> Thanks for your question.
>
> Any foreseen compatibility of the Arspec app and/or vocabulary with SHACL or the upcoming SHACL for UI spec?
>
> Short answer: not by adopting the vocabulary; possibly by reading it.
> SHACL was on the table when the Arspec vocabulary was designed, and it was set aside for a reason that holds for SHACL-UI too (which I had not seen before your mail; I have read the draft since). The two answer different questions. A shape describes a node and judges it: this is what a Person must look like, and here is the report on the ones that are not. A perspective describes statements and offers them: these are the rows to list, this is what to show of each, this is what an Add creates under that row and what the editor offers for this field. Validation and entry are different jobs, and what RDF lacked, as far as I could see, was a universal way to enter a graph, so that is what Arspec is built around. If your data already has shapes, SHACL-UI gives you a form for free; Arspec starts from the other end: you shape the form by hand over whatever data there is, and the result is a view, not a constraint.
> Concretely, a perspective is a tree of datasources. Each datasource is a condition over statements (subject, predicate, object, compared with constants or with the parts of the row it stands under) and yields one row per matching statement; its children are evaluated once per row. The same node then says what to display (ars:subjectVisible and kin, ars:objectViewMode rdfs:label), what the field's editor offers (ars:objectChoices, itself a condition over statements, not a query string), what Add seeds and Delete reaches, and which actions the row carries. Several perspectives live on one page at once: the file's tabs, and the lenses that open inside a record. All of it is edited in the app, in a form, with the view redrawing as you change it: https://arspec.app/doc/perspectives/#editor (the picture there, editor-light.png, is the datasource editor on the demo's People view). What the form writes is RDF in the file, beside the data, in the vocabulary at https://arspec.org/, so a perspective can be read back through the app's own Attributes view like any other triples, drafted by an AI assistant, and kept in version control.
> That is where SHACL-UI and Arspec part most clearly. The draft reaches for SPARQL where it needs computation: shui:searchQuery for autocomplete candidates, sh:select for enumerations, node expressions for computed values. Arspec has no query language anywhere; every condition is a small tree of triples the app can show, edit and explain, which is what lets the editor be a form rather than a text box. (SHACL 1.2's node expressions move some of this into RDF, which is closer, but they describe a computation to run, where an Arspec filter describes rows to show and edit.) Likewise sh:order and sh:group, shui:editor and shui:viewer and the widget scoring correspond to things a perspective states outright — order, nesting, value kinds, view modes and styles — on the datasource rather than on a property shape.
> The overlap that does exist is small and at the base: ars:minCount and ars:maxCount share SHACL's words, but on a datasource they say how many rows are seeded along with a new record and where a section stops offering Add — a behaviour of the form, not a constraint on the data.
> What I can foresee is a one-way bridge: drafting a perspective from a shapes graph. sh:targetClass would become the root condition, sh:property/sh:path the fields beneath it, sh:order and sh:group their order and sections, sh:name and sh:description the labels, sh:in the choices, sh:datatype/sh:class the kind the editor defaults to, sh:minCount/sh:maxCount the seeded rows. A draft, since a perspective says things a shape does not (what to show, what Add makes) and a shape says things a form cannot (patterns, SPARQL constraints). Nothing is scheduled; if people here would use it, that is what moves it up. Validation itself is not Arspec's job and will not become one: a validator's report is RDF, so it can be opened beside the data today, but Arspec no more validates than it reasons.
>
> Is this a product? "not fully public yet" means it will be eventually?
>
> Yes, it is a product, made by InfFront (inffront.com), and "not fully public" was about the packaging rather than the app: the desktop builds were unsigned and the store listings were in review. Since that mail 0.6.0 is out (https://arspec.app/whats-new/), with downloads for Windows, macOS and Linux, and the Google Play and Microsoft Store listings are in review as I write. The browser version at run.arspec.app has been open to anyone from the start, no account.
> It is free, and everything it does today stays free. The vocabularies and the RDF model layer are Apache 2.0 at github.com/arspec/arspec; the application's core is not open source now. Whether it becomes so depends on a longer bet, which is in the same repository: future/instruct.md sketches a small virtual machine stated in RDF, so that a program can be read, edited and run through perspectives like any other graph. If that turns into something solid, Arspec becomes a self-hosted language, and most of its own code is then open by construction, being RDF in files the app itself opens.
> Regards,
> Evgeny Sologubov.

Received on Monday, 2 November 2026 11:54:47 UTC