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
- The beta IDE is free — designing, Run and Debug, the examples, the
debugger, all of it, with no clock on it. Building an
.appneeds 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 license 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
- No runtime fee, no client license, 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.
How it works, and what it is built around
An application built with Neuridion contains no license check. Not a hidden one, not a friendly one, not a “just counting installations” one. That is how it works today, and it is not an afterthought in the pricing: it is the decision the product is built around, and the reason several otherwise attractive business models are not on our table.
The most concrete consequence: per-client licensing is not something we are planning, 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. And a mechanical check runs over every build we make, to prove the description above is still true of the binary we ship.
We have no intention of changing any of this — it is what the product is for. What you will not find here is the word ever, and that is deliberate rather than evasive. Nobody can promise for ever: a small company can be sold, a product can change hands, and a promise that only holds while nothing unusual happens is worth less than a plain description of how things are. So we describe, and we keep the description true — which is the part we can actually be held to.
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.
- 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 license, 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 .appruns on any Mac whose owner right-clicks once. So the gate sits at producing an.appat all.The moment a project becomes an
.app, a license 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 license model, it is a loophole with a polite name.
- A subscription ends — your shipped applications do not
Every application you already built keeps working, 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 license. 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.
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.
A built application carries a note saying which Neuridion made it and who held the license, 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.
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.
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.