BoneScript is a TypeScript DSL and Compiler for backend development, designed to let you define backend systems in a declarative, domain-oriented format that compiles into working application code and infrastructure artifacts.

It introduces a higher-level abstraction over traditional backend code by separating concerns into structured primitives like system, entity, and capability, where each maps to core backend concepts such as domain boundaries, data models, and executable business logic workflows.

heres an example .bone file

system DeliveryTest {
domain: marketplace

entity Driver {
owns: [name: string, capacity: uint, current_load: uint]
}

entity Order {
owns: [pickup: string, dropoff: string, weight: uint, status: string]
}

capability fulfill_order(order: Order) {
requires: [order.status == "pending"]
pipeline: {
validate_order(order)
reserve_inventory(order) as reservation
assign_driver(order) as assignment
notify_customer(order, assignment)
on_error: rollback
}
sync: transactional
timeout: 30s
}

capability find_route(start_node: string, end_node: string) {
algorithm: shortest_path using {
graph: road_network,
source: start_node,
target: end_node
}
returns: json
sync: eventual
idempotent: true
}
}

You would compile that and it would generate the files needed, meaning the DSL is transformed into a structured backend implementation. This includes generating the underlying TypeScript service logic, data schemas for entities, validation rules derived from requires clauses, and orchestration logic for pipeline blocks as executable workflows. Each capability is compiled into a deterministic execution unit, where step ordering, error handling (on_error), and execution guarantees (sync: transactional vs sync: eventual) are preserved in the generated runtime behavior.

Entities become typed data models with enforced ownership structures, while capabilities become callable backend operations with clearly defined inputs, outputs, and execution semantics. Pipeline steps are treated as discrete operations that are composed into a dependency graph, allowing the compiler to manage execution flow, intermediate results (like as reservation), and rollback behavior when failures occur.

In practice, this allows backend systems to be defined at a higher level of abstraction while still compiling down into fully functional backend services with predictable execution semantics.

BoneScript is a TypeScript DSL and Compiler for backend development, designed to let you define backend systems in a declarative, domain-oriented format that compiles into working application code and infrastructure artifacts.

It introduces a higher-level abstraction over traditional backend code by separating concerns into structured primitives like system, entity, and capability, where each maps to core backend concepts such as domain boundaries, data models, and executable business logic workflows.

heres an example .bone file

system DeliveryTest {
domain: marketplace

entity Driver {
owns: [name: string, capacity: uint, current_load: uint]
}

entity Order {
owns: [pickup: string, dropoff: string, weight: uint, status: string]
}

capability fulfill_order(order: Order) {
requires: [order.status == "pending"]
pipeline: {
validate_order(order)
reserve_inventory(order) as reservation
assign_driver(order) as assignment
notify_customer(order, assignment)
on_error: rollback
}
sync: transactional
timeout: 30s
}

capability find_route(start_node: string, end_node: string) {
algorithm: shortest_path using {
graph: road_network,
source: start_node,
target: end_node
}
returns: json
sync: eventual
idempotent: true
}
}

You would compile that and it would generate the files needed, meaning the DSL is transformed into a structured backend implementation. This includes generating the underlying TypeScript service logic, data schemas for entities, validation rules derived from requires clauses, and orchestration logic for pipeline blocks as executable workflows. Each capability is compiled into a deterministic execution unit, where step ordering, error handling (on_error), and execution guarantees (sync: transactional vs sync: eventual) are preserved in the generated runtime behavior.

Entities become typed data models with enforced ownership structures, while capabilities become callable backend operations with clearly defined inputs, outputs, and execution semantics. Pipeline steps are treated as discrete operations that are composed into a dependency graph, allowing the compiler to manage execution flow, intermediate results (like as reservation), and rollback behavior when failures occur.

In practice, this allows backend systems to be defined at a higher level of abstraction while still compiling down into fully functional backend services with predictable execution semantics.