Spanda

Website Content

Draft copy for a future Spanda project website. Use as-is or adapt for static site generators.

Homepage

Hero

Spanda — The Autonomous Systems Platform

Safety-first platform with a dedicated .sd language at its core. Build, verify, simulate, deploy, and operate autonomous systems.

Brand assets (repo assets/image/):

Asset	Use
`low_res_logo.png`	README, docs headers, nav
`logo.png`	Website hero
`banner.png`	Website banner strip
`app_favicon.png`	Favicon, VS Code extension icon
`high_res_logo.png`	Print, slides, high-DPI
`simple.png`, `template.png`, `files.png`	Social, docs templates

git clone https://github.com/Davalgi/Spanda.git
npm run build:rust
spanda run examples/showcase/rover_navigation.sd

Get Started · View on GitHub

Tagline

Build. Verify. Simulate. Deploy. Operate. — for autonomous systems.

The pulse of autonomous intelligence.

Philosophy

Hardware is the body.
Sensors are the senses.
AI models are the mind.
Actuators are the muscles.
Spanda is the intelligent pulse that transforms perception, intent, and safety into action.

Spanda (Pronounced SPUN-duh (/ˈspʌndə/)) is a Sanskrit term meaning the divine pulse — the creative vibration of consciousness and energy that manifests as expansion and contraction in all entities, bridging stillness and movement within consciousness; and the first stir of awareness that creates and sustains the universe.

Value proposition (3 columns)

Safety-first AI
LLMs propose actions. Only safety.validate() unlocks actuators. Compile-time and runtime enforcement.

Deploy with confidence
spanda verify checks sensors, memory, timing, and power against hardware profiles before you ship.

Robot-native syntax
Sensors, actuators, topics, tasks, and safety zones are language keywords — not framework boilerplate.

Code snippet (homepage)

robot Rover {
  sensor lidar: Lidar on "/scan";
  actuator wheels: DifferentialDrive;

  ai_model planner: LLM { provider: "mock"; }

  safety { max_speed = 1.0 m/s; stop_if lidar.nearest_distance < 0.5 m; }

  agent Navigator {
    uses planner;
    plan {
      let action = safety.validate(planner.reason(prompt: "Navigate", input: lidar.read()));
      wheels.execute(action);
    }
  }
}

Not replacing Python, C++, or Rust

Spanda orchestrates AI, robotics, safety, verification, and deployment. Keep your models in Python and drivers in C++.

Features page

AI-native agents

ai_model, agent, goal, memory
Mock providers for testing (no API keys required)
ActionProposal → SafeAction safety gate

Robotics primitives

robot, sensor, actuator, behavior, task every Nms
Physical units: m, s, rad, m/s
Trajectories, poses, transforms

Safety validation

Safety zones (circle, rectangle)
max_speed, stop_if, emergency stop
Compile-time rejection of unsafe AI patterns

Hardware verification

hardware profiles and deploy targets
spanda verify with matrix and fault injection
Built-in profiles: RoverV1, JetsonOrin, RaspberryPi5, ESP32

Communication

ROS2-style message, topic, service, action
In-memory simulator transport
Optional ROS2 adapter (experimental)

Simulation

spanda run / spanda sim
Physics-lite 2D backend
Test without hardware

Digital twins

twin { mirror pose; replay true; }
Shadow state and replay buffer

Real-time and reliability

Deadline-aware tasks: deadline, jitter <=, priority, critical isolated
Latency pipelines with budget enforcement
Watchdogs, operating mode blocks, recover from, retry/fallback
Wall-clock RTOS scheduling via --wall-clock

Mission trace replay

spanda sim --record writes JSON mission traces (v2 with state snapshots)
spanda replay --deterministic verifies frame parity against source
spanda replay --playback applies recorded state without re-running logic

Regular expressions

Regex literals, Regex / Match / Capture types
String methods, trigger and subscribe filters, validate rules

Package ecosystem

spanda init, build, test, install
spanda.toml manifest and lockfile

Tooling

Native CLI, LSP, web playground, WASM bindings
Formatter, linter, docgen

Architecture page

Headline

Rust core, TypeScript tooling, dual-layer architecture.

Pipeline diagram

.sd → lexer → parser → AST → type checker → interpreter + simulator

Optional: SIR → LLVM (experimental)

Layers

Layer	Technology
Language core	Rust (`spanda-core`)
CLI	Rust (`spanda-cli`)
Bindings	N-API, WASM
Developer UX	TypeScript, React, LSP

Link to architecture.md for full diagrams.

Examples page

Showcase demos

Example	Highlights
rover_navigation.sd	AI planning + SafeAction
warehouse_robot.sd	Tasks, comm, safety zones
ai_safety_violation.sd	Compile-time safety rejection
hardware_compatibility.sd	Deploy verification
communication_demo.sd	Message, topic, service, action
digital_twin_demo.sd	Twin + replay
killer_demo.sd	Safety-typed AI + verify + sim (see killer-demo.md)
deadline_tasks.sd	Real-time task contracts
basic_regex.sd	First-class regex

Quick commands

spanda run examples/showcase/rover_navigation.sd
spanda verify examples/showcase/hardware_compatibility.sd --json
spanda sim examples/realtime/deterministic_replay.sd --record
spanda replay mission.trace --deterministic

Roadmap page

v0.1.0-alpha (current)

Stable interpreter and type system
AI safety gate with mock providers
Hardware verification CLI
Simulation backend
Package manager (local registry)
Unified triggers, cooperative concurrency, real-time contracts, mission trace replay, first-class regex
Showcase examples and documentation

LLVM production backend
Published VS Code extension
Live AI providers (OpenAI, local models)
In-process Python/C++ FFI
ROS2 production adapter
Distributed multi-robot runtime

Long-term

Self-hosting compiler
Digital twin cloud sync
Fleet orchestration at scale

GitHub: github.com/Davalgi/Spanda
License: Apache-2.0
Docs: docs/README.md

This site is open source. Improve this page.