Software · System software
Compilers and runtimes
Languages, compilers and runtimes that turn your rules, formulas or scripts into fast, checked code.
When rules, formulas or configuration grow complex, a small purpose-built language is often clearer than code or spreadsheets. We design domain-specific languages and write the parsers, type checkers and compilers that target LLVM or WebAssembly, then build the runtimes and editor support around them, so experts write logic that is checked before it runs.
What we build
- Domain-specific languages for pricing, rules, workflows or test scripts
- Parsers and type checkers with clear, line-precise error messages
- Compiler back ends that emit LLVM IR, WebAssembly or JVM bytecode
- Sandboxed interpreters and runtimes for running untrusted user scripts
- Language servers giving editors completion, hover and go-to-definition
- Performance work on existing runtimes: profiling, JIT and GC tuning
DemoInteractive · sample data
Try it live.
A working sample with made-up data. It runs in your browser; nothing is sent anywhere.
dev@lang:~/rules$ cat discount.rule rule loyalty_discount(order: Order) -> Percent: when order.customer.years >= 3 and order.total > 5000 then 7.5% else 0% dev@lang:~/rules$ rulec check discount.rule
What it does well
Helpful errors
Messages point to the exact line and column and suggest a fix, not just an error code.
Checked before running
Types and rules are verified at compile time, so mistakes never reach live data.
Safe sandboxing
Scripts run with limits on memory, time and system access, and cannot touch the host.
Editor support
A Language Server Protocol server brings completion and diagnostics to VS Code and others.
Several targets
One source compiles to native code, WebAssembly for browsers or bytecode for the JVM.
Regression corpus
Golden-file and fuzz tests guard the compiler against regressions in every release.
Questions
When does a custom language make sense?
When domain experts keep asking developers to change rules, when the same logic must run in several places, or when spreadsheets have quietly become the system. A small language with a checker lets experts write the logic themselves while the compiler stops invalid rules before release.
Do you build on LLVM or write everything from scratch?
We reuse proven pieces. Parsing often uses tree-sitter or a hand-written recursive-descent parser for better errors, and code generation targets LLVM, WebAssembly or an existing virtual machine. Writing a full back end from scratch is rarely worth the cost.
Can you speed up our existing interpreter or runtime?
Often, yes. We profile real workloads first, then look at the usual causes: allocation churn, slow dispatch, missing caches and garbage collector settings. Changes are measured against a benchmark suite you keep, so gains are proven, not guessed.