Declarative
Autonomous Systems
ROS2 · WASM · Edge

Droe

Declarative Robotic DSL

Unifying robotics programming through structured intent, composable behaviors, and deterministic execution.

warehouse.droe 
task LoadPallet(pallet_id: string) requires Gripper.available
    sequence
        allocate Gripper
        call Navigate(goal = location(name = "staging"))
        call Pick(object = pallet_id)
        call Navigate(goal = location(name = "dock"))
        call Place(object = pallet_id)
        release Gripper
    end sequence
end task

mission FulfillOrder for PickerBot
    setup
        ensure logistics::OrderQueue.has_work == true within 5min
    end setup
    plan sequence
        start LoadPallet(pallet_id = "PALLET-42") as load_job
        await load_job within 4min else
            raise Failure("LoadPallet timed out")
        end else
        call Dock()
        notify ops::MissionLog(message = "Order PALLET-42 loaded")
    end plan
end mission

Intent-Driven

Specify what the robot should achieve, not how to achieve it. The compiler handles execution details.

Composable

Build complex behaviors from reusable primitives. Type-safe composition with compile-time verification.

Real-Time Safe

Guaranteed execution bounds. No runtime surprises. Predictable behavior under all conditions.

Cross-Platform Runtime

One language, multiple deployment targets. From cloud to edge.

ROS2

Middleware

Native integration with ROS2 ecosystem. Compile Droe behaviors to ROS2 nodes with automatic message handling.

$ droe build --target ros2

WASM

Portable

WebAssembly compilation for browser-based simulation, testing, and deployment. Run robot behaviors anywhere.

$ droe build --target wasm

Edge

Embedded

Optimized for resource-constrained environments. Minimal runtime footprint with zero-allocation execution paths.

$ droe build --target edge

Language Features

Designed for safety, expressiveness, and performance.

→ Type System

  • • Physical units as first-class types (meters, seconds, radians)
  • • Compile-time dimensional analysis prevents unit errors
  • • Affine types for resource management (sensors, actuators)
  • • Dependent types for constraint specification

→ Concurrency Model

  • • Actor-based message passing for distributed systems
  • • Deterministic scheduling for real-time guarantees
  • • Automatic deadlock detection at compile time
  • • Priority-based task execution with bounded latency

→ Safety Guarantees

  • • Memory safety without garbage collection
  • • Formal verification of critical behaviors
  • • Runtime bounds checking with zero overhead
  • • Fail-safe defaults and graceful degradation

→ Developer Experience

  • • Interactive REPL for rapid prototyping
  • • Built-in simulation environment for testing
  • • Visual behavior tree editor and debugger
  • • Performance profiler with real-time metrics

Compiler & Runtime

Multi-stage compilation pipeline with pluggable backends.

01. Frontend

Parsing, type checking, and semantic analysis

Seeking: Language Designers
  • → Syntax design and parser implementation
  • → Type inference and constraint solving algorithms
  • → Error reporting and IDE integration (LSP)

02. IR & Optimization

Intermediate representation and optimization passes

Seeking: Compiler Engineers
  • → Behavior tree optimization and pruning
  • → Dead code elimination and inlining strategies
  • → Loop optimization for real-time control loops

03. Backend & Runtime

Code generation and runtime system

Seeking: Systems Programmers
  • → Target-specific code generation (ROS2, WASM, native)
  • → Runtime scheduler with real-time guarantees
  • → Memory allocator for embedded systems

Target Applications

From research prototypes to production deployments.

Autonomous Vehicles

Self-driving cars, drones, and mobile robots requiring real-time decision making and sensor fusion.

perception → planning → control → actuation

Industrial Automation

Manufacturing robots, warehouse automation, and collaborative robots with safety-critical requirements.

task_planning → motion_control → safety_monitoring

Embedded Agents

Resource-constrained devices running autonomous behaviors with minimal power consumption.

sense → decide → act [<1ms latency]

Research Platforms

Academic research in robotics, AI, and control theory with reproducible experiments.

prototype → simulate → validate → deploy
Open Collaboration

Shape the Future of Robotics

Droe is in active development. We're seeking researchers, compiler engineers, roboticists, and systems programmers to collaborate on language design, compiler implementation, and runtime development.

# Join the community
$ discord.gg/sA3Cnp7t
Declarative
Intent-Driven Design
Safe
Formal Verification
Fast
Real-Time Execution
Portable
Multi-Platform

Open Research Questions

Fundamental challenges we're tackling together.

🔬 Type System Design

How do we express physical constraints, timing requirements, and resource bounds in a type system that's both expressive and decidable?

⚡ Deterministic Scheduling

What scheduling algorithms guarantee bounded latency while maximizing throughput in multi-agent systems?

🧩 Behavior Composition

How can we compose complex behaviors from simple primitives while maintaining formal guarantees about the composed system?

🎯 Cross-Platform Optimization

What IR design enables effective optimization across vastly different targets (cloud, edge, embedded)?

Technical Specifications

Language Properties

Paradigm Declarative, Functional
Type System Static, Dependent, Affine
Memory Model Ownership-based, No GC
Concurrency Actor-based, Deterministic

Runtime Targets

ROS2 Humble, Iron, Rolling
WASM WASI, Component Model
Embedded ARM Cortex-M, RISC-V
Native x86_64, ARM64