Deterministic orchestration
for distributed software.

Ved is a declarative systems programming language for building reliable control planes that continuously stabilize complex software environments.

Describe how systems should behave. Let the runtime make them stable.

Explore Development Experience View on GitHub

Operating distributed systems is still fragile.

Modern software platforms are composed of many interacting services, queues, agents, and infrastructure layers. The logic that governs deployment, scaling, recovery, and coordination is often implemented using...

The limit: Sequential, step-by-step scripts fail unpredictably halfway through, leaving systems in unknown partial states that require manual intervention.

The Ved approach: Ved uses declarative goals. The runtime continuously calculates and executes the safest path to equilibrium regardless of the starting state.

The limit: Developers spend countless hours writing redundant loops, error handling, and retry logic just to watch for simple state changes.

The Ved approach: Ved's runtime intrinsically provides the observation and execution loop, letting you write only the exact domain logic and transition bounds.

The limit: Live systems drift from their declared configuration due to manual changes, edge cases, or silent failures, leading to unstable environments.

The Ved approach: Ved constantly cross-references live actual state with declared desired state, actively scheduling transitions to repair deviations automatically.

The limit: Race conditions and asynchronous task scheduling cause intermittent, impossible-to-reproduce bugs in distributed networks.

The Ved approach: Ved processes orchestration logic in strictly sequential, deterministic slices, making every system transition 100% reproducible and testable.

As systems grow, operational behaviour becomes harder to reason about and failures become harder to reproduce.

Ved treats system behaviour as a program.

Ved programs define:

Concept: The canonical representation of the domain logic.

Purpose: State definitions explicitly encode exactly what properties of a system determine its behavior, automatically versioned and schema-managed.

Concept: Expressions describing what a valid state looks like.

Purpose: Instead of writing imperative checks, you declare specific invariant rules (predicates). If any rule fails, the system knows it is out of equilibrium.

Concept: Strictly pure functions that map from state to state.

Purpose: Transitions encode safe pathways between states. They are recorded and fully replayable without any network or disk IO side-effects mutating them under the hood.

Concept: Cryptographically enforced bounds on who can mutate state.

Purpose: Defines exact Role-Based limitations baked directly into the compiler, ensuring unauthorized transactions are dropped before they even reach the executor.

The runtime continuously evaluates current conditions and drives the system toward declared equilibrium states. This shifts orchestration from reactive scripting to analyzable system evolution.

Deterministic execution loop

observe state→evaluate goals→schedule transition→persist mutation→emit effects→repeat

Ved executes orchestration logic in discrete deterministic slices. External side-effects are recorded and replayable, enabling reproducible debugging and crash-safe recovery.

Example: self-stabilizing worker pool

domain WorkerPool {
  state {
    desired: int
    actual: int
  }

  goal Stable {
    predicate actual == desired
  }

  transition ScaleUp {
    step {
      emit ProvisionWorker()
    }
  }
}

The runtime continuously reconciles actual system state with declared goals.

Runtime behaviourtick=1 desired=3 actual=0 → scheduling ScaleUp
tick=2 actual=1
tick=3 actual=2
tick=4 actual=3 → goal Stable satisfied

Project structure

ved-runtime — deterministic execution engine
ved-compiler — language frontend and semantic validation
ved-cli — operational tooling

Ved is being developed in public with a focus on validating deterministic orchestration semantics before distributed runtime expansion.

Development roadmap

Deterministic scheduler prototype
Persistent state journal
Replayable execution model
Syntax and IR stabilization
Convergence analysis tooling
Distributed runtime research

Frequently Asked Questions

Ved is a deterministic control-plane programming language designed to help engineers build reliable, long-running distributed systems. It enables developers to describe desired system behaviour using structured state models, goals, and bounded execution logic.

Modern distributed systems are difficult to operate because orchestration logic is often:

imperative
non-deterministic
difficult to reproduce
prone to configuration drift

Ved introduces a deterministic execution model that helps systems converge toward stable operating conditions.

Ved focuses on orchestration behaviour rather than application logic. It provides built-in concepts such as persistent system state, convergence goals, structured authority boundaries, and replayable execution, which are not primary concerns in most general-purpose languages.

No. Ved is intended to complement existing languages by governing system behaviour at the control-plane level. Application services and data-plane logic can continue to be implemented using traditional languages.

Deterministic execution means that given the same initial state and external inputs, the runtime will evolve the system in the same way every time. This enables reproducible debugging, predictable recovery, and improved operational reasoning.

Goals represent stable desired conditions for the system. The runtime continuously evaluates current state and executes transitions that help the system move toward satisfying these goals.

Yes. External interactions are modeled as explicit effects. These effects are isolated, recorded, and replayable, allowing the runtime to maintain deterministic behaviour while operating in unpredictable environments.

Ved is primarily designed for control-plane orchestration and long-lived system coordination. It is not intended to replace traditional application frameworks.

Ved is currently in early design and prototyping stages. The project focuses on validating deterministic runtime semantics and convergence models before expanding toward broader production use.

Orchestrate complex software with certainty.

Deterministic orchestrationfor distributed software.