How licensing works

The tool is licensed. What it builds is not.

That is the whole model in one line, and the rest of this page is only the detail. You pay for Neuridion. The people who use the applications you make with it pay nothing — not once, not per seat, not per year — because there is nothing in those applications to pay for. No key, no expiry, no call home.

You, the developer

Neuridion is a subscription

119 €a year, from version 1.0

The beta IDE is free — designing, Run and Debug, the examples, the debugger, all of it, with no clock on it. Building an .app needs the subscription, in the beta exactly as after 1.0 (changed 22 August 2026 — it briefly included free builds).
Designing, Run and Debug never need a key, in any version, for anybody. A licence is wanted the moment a project becomes an application — test build and release build alike.
A year, not a month. Yearly only — a professional tool you build a business on, kept up to date all year, at a flat price that does not move while you stay subscribed.
Every version released during your year is included — update whenever you like, at no extra cost, for as long as the subscription runs.
Your price does not move while the subscription runs without a break. We keep that promise by doing nothing: the payment provider behaves that way by itself.
Neuridion PRO, 599 €, available from version 1.0, is the client/server tier — with unlimited seats, because a counted seat would need a number inside a built server, and that is the one thing that never happens here.

Them, your customers

Applications you build are free

0 €for ever, to anybody

No runtime fee, no client licence, no “deployment seat”, no per-user anything.
No expiry. An application built with Neuridion works in ten years exactly as it works today, whether or not we are still here.
No key to type in, and nothing to activate. Copy it to a second Mac and it starts.
Nothing is reported to us — not that it is running, not who is running it, not what it holds.
Their data is a SQLite file. Readable by anything that speaks SQL, with or without Neuridion, with or without us.

The sentence that will never be revised

An application built with Neuridion contains no licence check. Ever. Not a hidden one, not a friendly one, not a “just counting installations” one. This is not a current policy that a future price list could quietly walk back — it is the decision the product is built around, and the reason several otherwise attractive business models are ruled out here rather than considered.

The most concrete consequence: per-client licensing is not going to happen, because it would need a client count living inside a built server, and a count is a check. That is why PRO has unlimited seats. The pricing follows the promise; the promise does not follow the pricing.

No key inside a built application No expiry date inside a built application No network call inside a built application No seat, user or installation count No telemetry, no usage reporting No kill switch, in any form

In practice

Where the barrier actually sits.

There is exactly one gate, and it is late. Everything before it is open — which is deliberate: you should be able to find out whether this tool suits you by using it on something real, not by reading a feature matrix.

The Licence page in Neuridion's settings: the state of this Mac, whether building is open, and the accepted agreement — The whole licence, in one page of the settings — what this Mac is licensed for, whether building is open, and the terms as accepted. The paragraph under it is the promise itself, where the person who might doubt it can read it.

Designing, running, debugging — no key needed
Draw the schema, build the windows, write the scripts, press ▶︎ and use the finished application, step through the debugger, read the query log, browse the data. All of it, with no licence, for as long as you like, on as many Macs as you like. This is the loop you spend the day in and it is the part that is never gated.
Turning it into an application — this is the gate

Even this one — Test build: quick and unsigned, to try out on this Mac. It used to be free, and that meant shipping was free if you could live with a warning dialog: an unsigned .app runs on any Mac whose owner right-clicks once. So the gate sits at producing an .app at all.

The moment a project becomes an .app, a licence is wanted — test build and release build alike, in the beta exactly as after 1.0. And one thing comes from Apple rather than from us: a release build is signed and notarized with your own Developer ID, which needs Apple's Developer Program (about 99 € a year, paid to Apple). A test build signs ad-hoc and needs no Apple account.

It was only the release build until 21 August 2026, and the change is a correction rather than a tightening. An unsigned test build runs on any Mac whose owner right-clicks it once, so exempting it amounted to “shipping is free if you can live with a warning dialog” — which is not a licence model, it is a loophole with a polite name.
A subscription ends — your shipped applications do not
Every application you already built keeps working for ever, on every Mac, and never checks anything — that is the promise, and it is untouched. The IDE keeps designing, running and debugging with no key. What waits until you renew is producing a new build: you rent the workshop, not the things you made in it. No read-only mode, nothing crippled, and nothing added to what you ship — building simply resumes when the subscription does. Every build has always carried the same imprint: which Neuridion made it and the name on the licence. It is read by nothing, it changes nothing, and a lapsed subscription does not touch it either — the card further down says exactly what is in it.
Schools need nothing from us, and that is not a discount
There is no education key to apply for, no form, no proof of enrolment, nothing to ask us for. Run and Debug are the whole of what a classroom does — a pupil draws the data model, presses ▶︎, and their application opens and works: real windows, real records, reports, the debugger, the data browser. A full term of teaching happens on that side of the line, on every machine in the room, without anybody typing a key. A school only meets the gate if it wants to hand a finished application to somebody outside the school, which is not what a lesson is.

Honestly

What the key does, and what it cannot do.

The check lives in the IDE, and only there

When you enter a key, Neuridion asks the payment provider whether it is valid and which product it belongs to — a key for a different product of ours is refused rather than accepted for being well-formed. That is one request, made by the tool on your Mac, when you type the key.

The build stamp is an imprint, not a check

A built application carries a note saying which Neuridion made it and who held the licence, inside the sealed payload. Nothing reads it back: remove it and the application behaves identically. It is there so a question of provenance has an answer, and it is shown in the About window rather than hidden.

We call it protected, not uncrackable

Your scripts travel encrypted inside the application, and the word for that here is protected. Anything that runs on somebody else's machine can eventually be taken apart by somebody determined; a vendor who tells you otherwise is selling you a feeling. We would rather be believed about the things that matter.

And the IDE does look for updates

Neuridion asks our server once whether a newer version exists. That is the tool, not what you build — and it means our server logs a request. It is written down in the privacy notice rather than left as a footnote, because a promise about telemetry is only worth what its exceptions are worth.

Carry on.

Pricing & download

The beta IDE is free; building is what the subscription buys.

Questions

The ones that actually decide it — answered short.

Privacy

Every network request this software makes, listed.