Colang is NVIDIA's domain-specific language for declaring dialog flows and rails: input rails, output rails, retrieval rails, dialog rails, and execution rails. Flows read like a conversational script with natural-language intents (define user ask_for_refund) and named actions. The DSL exists because rails are a policy artefact that non-engineers (security, compliance, product) need to read and review; Python is too expressive and easy to bury intent inside conditionals. Colang's structure makes the rail decision tree auditable, diffable in PRs, and analysable by tooling. The runtime is implemented in Python under the hood.
**Colang is NVIDIA's domain-specific language for defining NeMo Guardrails rails.** Rails are policy decisions about what the LLM is allowed to receive, generate, and act on. Colang lets you declare them as flows.
A Colang file declares five kinds of rails:
- **Input rails**, run on the user's message before it reaches the LLM (PII scrubbing, jailbreak detection).
- **Output rails**, run on the model's response before it reaches the user (toxicity check, citation enforcement).
- **Retrieval rails**, run on documents pulled by RAG before they enter the prompt.
- **Dialog rails**, pattern-match conversation flow against named intents.
- **Execution rails**, wrap tool calls with checks and confirmations.
A flow reads like a script:
```
define user ask_for_refund
"I want a refund"
"can I get my money back"
define flow handle_refund
user ask_for_refund
if $user_verified
bot offer_refund_process
else
bot ask_for_verification
```
The value over plain Python is auditability. A security officer, compliance reviewer, or product manager can read the flow above, understand the policy, and approve or reject it. Translate the same logic into Python with nested conditionals and the policy gets buried in implementation detail. NVIDIA chose a DSL specifically so non-engineers can review rails as policy artefacts.
**Colang is a declarative DSL for defining NeMo Guardrails rails, input, output, retrieval, dialog, and execution.** It looks like conversational pseudocode: named user intents, named bot responses, named flows that wire them together. The runtime that executes Colang is plain Python; Colang is the surface humans read and write.
The DSL exists because rails are a policy artefact, not a code artefact. The people who need to approve a rail include security, compliance, product, and legal, not just LLM engineers. A Python file expressing the same policy via nested `if`/`elif`/`try`/`except` is unreviewable by that audience. Colang collapses a typical rail into a few lines of declarative flow that maps cleanly to the policy decision being made.
The DSL also makes the rail tree analyseable. Because flows are named and intents are explicit, tooling can do things plain Python cannot: enumerate every path through the dialog rails, surface coverage gaps, diff two versions of a policy in PRs, generate test cases from the intent set. NVIDIA can build static analysis on Colang in a way that would be infeasible on arbitrary Python.
The trade-off is expressiveness. Colang covers the conversation-flow and rail-decision shape well; for non-rail work (custom retrievers, custom tools) you drop into Python via action handlers. The split is intentional: rails in Colang, implementations in Python. Mixing the two in one language is what you get from older guardrail frameworks, and it is exactly the readability problem Colang exists to solve.
Quick reference
TL;DR
Colang is NVIDIA's declarative DSL for defining NeMo Guardrails rails. The DSL exists so non-engineers can read, review, and audit policy without parsing Python control flow.
Imagine an airport with rules about who can fly. You could write those rules as a thick programming book full of loops and if-statements only engineers can read. Or you could write them as a short list: 'if the passenger is on the no-fly list, deny boarding; if they have a valid ticket and pass screening, allow.' Both reach the same decision, but the list is something the safety officer, the airline lawyer, and the regulator can all read. Colang is the second kind. It is a small language for writing the rules that decide what a chatbot is allowed to say and do, written so that people who are not engineers, security, compliance, product owners, can read and audit the policy without learning Python.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Small prototype where engineers are the only reviewers and rails are minimal The DSL's audit-readability benefit is wasted when no non-engineer will read the rails; a few lines of Python suffice.
Rails that require complex stateful logic across multiple turns and tool calls Colang's declarative shape gets awkward when policy depends on rich state; either factor the state into Python actions or pick a different framework.
Teams that have no compliance, security, or product reviewers in the loop Without the non-engineer audience, the DSL's value proposition collapses; the overhead of learning Colang is not repaid.
Quick scan · 2–4 min
Everything important, quickly.
3 min: Colang is NVIDIA's declarative DSL for the five rail types (input, output, retrieval, dialog, execution); DSL exists because rails are a policy artefact non-engineers (security, compliance, product) must read; named intents and flows enable static analysis, PR diffing, and coverage reports plain Python cannot; Python action handlers implement mechanism, Colang declares policy.
Real-world examples
Real products, models, and research that use this idea.
1NVIDIA NeMo Guardrails 0.10+ in 2026 ships Colang 2.0 with stronger typing for actions and improved tooling for policy diffing.
2Enterprise deployments at financial institutions use Colang files in version control as the auditable policy artefact reviewed by their model-risk committee.
3The NeMo Guardrails toolkit includes a CLI that statically analyses Colang flows to surface unreachable paths and missing intent coverage.
4Colang flows are commonly diffed in pull requests so security and compliance can approve policy changes without reading the Python runtime.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow does Colang's declarative shape help when you need to prove rail coverage to an auditor?
Sign in or go Pro to see the approach for this follow-up.
QWhat goes wrong when teams move rail logic into Python action handlers?
Sign in or go Pro to see the approach for this follow-up.
QHow does Colang compare to Guardrails AI's RAIL specification format?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Treating Colang as a 'lite' Python that engineers use because it is easier. The point is the opposite: it is a policy artefact non-engineers must read.