DSL

Domain

Host Language

Domain-specific advantage

sbt

Build automation

Scala

Declarative build definitions with compile-time checks

Slick

Database queries

Scala

Type-safe SQL abstractions with static checks

Chisel

Hardware design

Scala

Parametric circuit generation with type checks

Leon

Program verification

Scala

Solver-aided verification of functional correctness

Akka HTTP

Web APIs

Scala

Declarative routing with compile-time safety

Rocket

Web APIs

Rust

Declarative routing with macro-based type safety

Serde

Serialization

Rust

Macro-driven derive for efficient serialization

Behave

BDD testing

Python

Natural-language test scenarios with domain readability

SQLAlchemy

Database queries

Python

SQL-like queries with runtime checks and composability

GeoPandas

Geospatial analysis

Python

Geometric operations with domain-specialized data structures

PyTorch

Machine learning

Python

Dynamic graphs and GPU-accelerated execution

TensorFlow

Machine learning

Python

Graph-based ML computations with optimized execution

MetPy

Meteorology

Python

Prebuilt meteorological functions with domain syntax

transitions

State machines

Python

Declarative state machines with visualizable transitions

pytest

Testing

Python

DSL-like tests with introspection and fixtures

Snakemake

Workflow management

Python

Declarative workflows with automatic parallelization and caching

UFL

PDE solving

Python

Symbolic PDEs with automatic code generation

SymPy

Symbolic mathematics

Python

Symbolic computations with domain syntax

PyMC

Probabilistic programming

Python

Compositional Bayesian models with MCMC inference

Mimi

Climate modeling

Julia

Modular integrated assessment models with domain abstractions

ModelingToolkit

Symbolic modeling

Julia

Symbolic computations with optimized code generation

AWS CDK

Infrastructure as code

JavaScript

Type-safe infrastructure definitions with compile-time checks

GraphQL

API queries

JavaScript

Schema-driven queries with static validation

styled-components

CSS generation

JavaScript

CSS-in-JS with dynamic props and tooling

D3.js

Data visualization

JavaScript

Declarative visualizations with data-driven transformations

HipHop.js

Synchronous reactive programming

JavaScript

Synchronous concurrency with deterministic reactive semantics

Vega-Lite

Data visualization

JavaScript

Schema-driven charts with automatic encodings

Drools

Business rules

Java

Readable rule-based logic with static analysis

Flix

Logic programming

Java

Datalog-based logic with static type checking

jOOQ

Database queries

Java

Typesafe SQL queries with compile-time checks

Gremlin

Graph queries

Java

Traversal-based graph queries with optimizations

Apache Camel

Integration patterns

Java

Fluent routing and mediation with type checks

RxJava

Reactive streams

Java

Asynchronous pipelines with fluent reactive operators

HaTeX

Document generation

Haskell

Type-safe LaTeX generation with composable abstractions

Copilot

Runtime verification

Haskell

Stream-based temporal checks with compile-time assurances

Yampa

Functional reactive programming

Haskell

Continuous-time FRP with modular signal functions

Accelerate

GPU computing

Haskell

Parallel computations to efficient GPU code

GPipe

GPU computing

Haskell

Type-safe 3D pipelines with static checks

Euterpea

Music composition

Haskell

Functional music composition with type-safe abstractions

Parsec

Parsing

Haskell

Pure combinators with static guarantees

monad-bayes

Probabilistic programming

Haskell

Monadic probabilistic models with inference capabilities

Servant

Web APIs

Haskell

Type-level API specification with static enforcement

Garden

CSS generation

Clojure

Programmatic CSS with variables and macros

Specter

Data manipulation

Clojure

Declarative transformations with composability

Datomic

Database queries

Clojure

Temporal Datalog queries with immutable history

Hiccup

HTML templating

Clojure

HTML as data structures with macros

core.logic

Logic programming

Clojure

Relational logic with unification and constraints

Instaparse

Parsing

Clojure

BNF-like grammar directly in code

FParsec

Parsing

F#

Composable parser combinators with strong static guarantees

LINQ

Database queries

C#

Integrated queries with static checks

Bloom

Distributed systems

Ruby

Declarative logic for eventually consistent distributed computations

Halide

Image processing

C++

Decoupled scheduling with performance optimizations