make any llm speak your dsl
paste your domain-specific language’s grammar. dsl·ai turns it into generation that can’t be syntactically wrong and a parser that tells you exactly where input breaks. no fine-tune, no gpu.
✓ grammar parses
hit generate — every line is sampled inside the grammar, so it always parses.
fine-tuning, and hoping
- fine-tune and pray the model learned your syntax
- frontier models follow a grammar “usually” — not always
- a single wrong token still ships invalid output
- you trust the model to grade its own homework
valid by construction
- the grammar becomes a hard decoding mask
- syntactically invalid output is impossible, not unlikely
- a real parser pinpoints the exact error position
- free, in the browser — no training, no gpu
output that can't be wrong
fine-tuning hopes the model learned your syntax. dsl·ai constrains it: the grammar becomes a decoding mask, so every token stays inside the language. syntactically invalid output is not unlikely — it's impossible.
the same grammar drops in as a gbnf constraint for a hosted open model, so the guarantee follows you from the playground to production.
# every token masked to the grammar alert cpu > 90% for 5m then page oncall ✓ valid by construction▌
validation you can trust
validation runs on a real generated parser, deterministically. it returns valid or invalid plus the exact position and what was expected — the kind of error a compiler gives, not a confidence score.
wire it into ci to reject malformed dsl in a pull request before it ever ships.
validate "alert cpu > 90x" ✗ invalid at position 14 expected "%" or " for " but got "x"
the cheap path, on purpose
the wedge needs no training and no warm gpu — it runs in the browser. fine-tuning a small open model is an optional upsell for hard semantic cases, served multi-lora so one base model fans out across every customer's adapter.
you orchestrate on vercel; heavy compute stays external and pay-per-use.
browser ▸ playground (free) vercel ▸ orchestration multi-lora ▸ fine-tune (paid) # gpu stays external, pay-per-use
three steps, zero training
the same path the playground takes — and the same grammar drops straight into a hosted model in production.
- 1
bring your grammar
paste your dsl's grammar — ebnf/gbnf-style rules, the same thing you'd write for a parser. plus docs and examples if you have them. no training set required.
- 2
constrain the model
dsl·ai compiles the grammar into a decoding constraint, so generation can only ever stay inside your language. the output is valid by construction — not valid if you're lucky.
- 3
generate & validate
generate snippets that always parse, and validate any input deterministically — a real parser pinpoints where it breaks, never an llm guessing yes/no.
# grammar → guaranteed-valid output alert cpu > 90% for 5m then page oncall ✓ valid by construction▌
syntactically valid output
gpus to fine-tune
accounts to try it
grammar in
questions
what is dsl·ai?
dsl·ai makes an llm reliably produce your domain-specific language. you give it your dsl's grammar; it compiles that into a generation constraint (so output is syntactically valid by construction) and a deterministic validator (a real parser that pinpoints errors). the playground runs both with no account and no gpu.
do i have to fine-tune a model?
no — and that's the point. for most dsls, grammar-constrained decoding plus retrieval over your docs and examples beats fine-tuning on cost, speed, and correctness, because it makes invalid output impossible rather than merely less likely. fine-tuning is an optional premium tier for hard semantic cases on small self-hosted models.
how is this different from just prompting gpt or claude?
a frontier model can usually follow a grammar in-context, but 'usually' isn't a guarantee — it can still emit a token that breaks your syntax. dsl·ai applies the grammar as a hard constraint during decoding, so the result always parses, and pairs it with a deterministic validator instead of trusting the model to check itself.
what does the validator return?
valid or invalid, the furthest position it parsed to, and what it expected there — for example: invalid at position 21, expected "." or " for " but got "m?#". it's a parser, so the verdict is exact and reproducible, never a probability.
can i call it from my own code?
that's the roadmap's headline: a hosted api and a ci validation check so you can generate and validate your dsl from your own pipeline. the mvp ships the playground; the api and private-adapter hosting are the paid tiers built for platform-engineering teams with internal dsls.
is it free?
the constrained-generation and validation playground is free and on-device. paid tiers add the hosted api, ci validation, retrieval over your docs, and optional fine-tuning on self-hosted open models. built in public as part of ogbuilds.
your dsl, spoken fluently
try it with your own grammar — it runs in your browser, free, no account.