Devlish — Build software using English

Why it is different

The source is the program.

Most tools that promise plain-English programming generate code you still have to review. In Devlish, the English is the code.

Readable source, not generated code

Compliance teams read it, auditors trace it, machines execute it, and AI writes it in the same form you review. One artifact for everyone.

Deterministic by design

The same input always produces the same output, with a machine-readable audit trail. When rules decide who gets paid, "probably right" is not a feature.

Zero runtime dependencies

A compiler and VM in pure Rust. Compiles to portable bytecode; runs natively or in any browser via WebAssembly. No install, no excuses.

What people build

Rules that both people and machines can read.

Each of these runs in the playground above. Load it, change a value, run it.

Compliance automation

Encode regulatory tests, like the IRC Section 45 energy community bonus, as programs an attorney can read and an auditor can trace.

Load the energy community example

Claims and payments

Verification workflows that decide approve, escalate, or deny, with the decision logic sitting in plain English instead of buried in a script.

Load the claims triage example

LLM tool building

Give an agent a structured tool interface. Checkpoints pause a running program for AI or human review before anything irreversible happens.

Load the invoice example

Learning to program

Teach real programming concepts, variables, conditionals, loops, without the syntax wall. A free 7-module course starts from zero.

Open the course

LLM-native

Build tools your AI actually calls.

Every Devlish program is an MCP tool. Your LLM sends JSON in, gets structured JSON back. No prompt parsing, no hallucinated logic, no credentials exposed.

# This IS the tool. The LLM calls it via MCP.
Ask "Customer tier?" as customer_tier
Ask "Deal size?" as deal_size

discount_rate equals 0.05
If customer_tier is "enterprise"
  discount_rate equals 0.15

Respond with record with deal_size times discount_rate as discount

MCP server built in Run devlish mcp and every .dvl file becomes a tool Claude, GPT, or any MCP client can call.

Structured JSON responses Respond with returns typed JSON. Fail with returns structured errors the LLM can parse and retry.

Token-efficient by design Toolrun compression strips noise from shell output. Compiled rules cost zero tokens per execution after the first review.

How LLM integration works

Ship rules as code

Drop business rules into any React, Next.js, or Node app.

Install one package. Load a compiled rule file. Get a result. Your rules run inside your app the same way a font or an image does: as a static asset, not a separate service.

import { loadTool } from "devlish-runtime";

// Load a compiled rule (like loading any JSON file)
const tool = await loadTool({
  bytecode: await fetch("/rules/pricing.dvlc.json").then(r => r.json())
});

// Run it with your data
const result = await tool.run({ customer_tier: "enterprise", deal_size: 500000 });
console.log(result.response); // => 75000

One npm install Works with React, Vue, Svelte, Next.js, plain TypeScript, or Node scripts. No backend needed.

Rules cannot escape Programs run in an isolated sandbox. They cannot access your network, read files, or touch anything outside the data you pass in.

Runs off the main thread Execution happens in a background thread by default, so your UI stays responsive even with complex rules.

npm install devlish-runtime

How it works under the hood

How it compares

Devlish versus the usual options.

The gap Devlish closes: business teams need to read the logic, and machines need to run it, from the same artifact.

Property	Devlish	Vibe Coding	App Builders	APIs
Non-engineer can read the logic	Yes, the English is the source	No, AI writes code you cannot review	Hidden behind drag-and-drop UI	No, only the API docs are readable
You own the source code	Yes, plain text files in your repo	Yes, but unreadable generated code	No, locked in the platform	N/A, logic lives on someone else's server
Host anywhere	Yes, browser, Node, edge, CLI	Yes, standard deploy targets	No, vendor platform only	Depends on the provider
Deterministic, auditable execution	Yes, with an event trail	No, depends on the generated code	Rarely exposed	Depends on the API
Built for LLM collaboration	Yes, MCP server + JSON structured output	No, LLM generates code, does not call it	No, no tool interface	Partly, if the API is well-typed
Enforced permission boundaries	Yes, Program Manifest	No, full system access	Vendor controlled	API key scoping only
One artifact for humans, AI, machines	Yes	No, code plus prompts plus docs	No, config plus runtime plus docs	No, OpenAPI spec plus implementation

Devlish came out of a specific, recurring pain. I run a company that handles IRS Section 6418 tax credit transfers, and our compliance rules lived in Python that the compliance team could not read. Every rule existed twice, once in a policy document and once in code, and the two drifted until an audit found the gap.

So I built a language where the readable English version is the only version. It has since run real energy community validations, receipt processing, and invoice reviews. It was born in production, not a lab.

— Andrew Dubinsky, founder of DealStar

~10k lines of Rust 26 built-in functions 53 example programs 69 compiler tests 25 end-to-end tests 7-module course File I/O: PDF · XLSX · DOCX · CSV · JSON VS Code extension npm: devlish-runtime

Learn from zero

Programming without the syntax wall.

A free, interactive 7-module course that teaches real programming concepts through Devlish. No prior experience assumed.

Start the course

0Getting started

1Values and names

2Decisions and logic

3Repetition and collections

4Methods and classes

5Real programs

6Testing and debugging

Stay in the loop

Follow the pre-1.0 build.

Occasional updates on language design, new releases, and early-adopter openings. No noise.

We will wire this to the newsletter provider at launch. For now it validates but does not send.