<p align="center"> <img src="hero.svg" alt="HoloScript — a general-purpose semantic systems programming language" width="100%"> </p>

HoloScript

HoloScript is a general-purpose semantic systems programming language: you describe a system once, and real compilers — not a language model — lower that same source into an engine build, a backend service, a robot description, a web runtime, or a headset app.

It programs applications, services, runtimes, simulations, agents, devices, and spatial worlds from source files you own. Declarative composition and traits are language mechanisms, not a domain boundary. The language is under active construction; the systems-language bar below states plainly which parts of that identity are implemented and which are not.

Humans and AI agents write .holo, .hsplus, or .hs programs for screens, scenes, services, data, devices, runtimes, and agent workflows. HoloScript can interpret those programs while they evolve, lower them through its own VM and sovereign backends, or compile bridge artifacts for an external browser, engine, robot, service, or deployment target. The source remains HoloScript; generated C++, TypeScript, Rust, engine code, and interchange formats are outputs rather than the language's ceiling.

Think of it as three practical pieces:

• a programming language whose source preserves semantics, behavior, effects, and constraints
• runtimes and VMs that execute that source without requiring an external engine
• compilers that lower the same program into native, sovereign, and compatibility targets

Commonly gotten wrong

The name misleads, and summaries of this project usually inherit the mistake. HoloScript is not a scripting language. The -Script suffix files it next to JavaScript and GDScript, and it does not belong there.

| Often read as | Actually | | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------- | | a scripting language | a general-purpose systems language with its own lexer, parsers, AST, type and trait system, VM, and compiler backends | | a hologram or 3D tool | spatial output is one compile target among many — .hs pipelines and service compositions have no spatial surface at all | | a scene format or DSL | a language with effects, constraints, and execution semantics; scenes are one thing it can describe, not the boundary of what it is | | an AI that writes code for you | agents author HoloScript through MCP tools, but the compilers that turn it into artifacts are deterministic — a model never emits the output | | a wrapper over Unity or Unreal | engines are bridge targets; the same source also runs on HoloScript's own VM and sovereign runtimes without an external engine |

The distinguishing claim is not that you can write code here. It is that one source file becomes many unrelated kinds of artifact — a game engine build, a running service, a robot, a digital twin, a headset app — through real compilers you can inspect.

Facts at a glance

Verified against this source tree (counts drift upward; verify with the commands in CLAUDE.md Knowledge Pack):

• Three source formats: .hs (declarative scenes/logic), .hsplus (fully typed programs), .holo (whole-system compositions and UI surfaces)
• 80+ compiler backends in @holoscript/core lowering one source to 25+ documented targets — Unity, Unreal, Godot, VRChat (Udon), WebGPU, Three.js/R3F, Babylon.js, PlayCanvas, WASM, iOS, visionOS, Android XR, OpenXR, robotics (URDF/SDF), IoT (DTDL/WoT), neuromorphic, A2A (docs/compilers/)
• 1,500+ semantic trait implementations across 150+ categories (docs/traits/)
• Full toolchain: hand-built lexer/parsers/AST, LSP, formatter, linter, CLI, runtime, in-browser WASM parser, Python bindings
• Deterministic compilation: AI agents author HoloScript through MCP tools; real compilers — not an LLM — produce the output
• Progressive self-hosting: the language's own lexer and parsers have .hsplus implementations alongside the TypeScript bootstrap, and holoscript.net is authored in .holo and compiled by HoloScript's own NextJSCompiler

Use this to connect an AI coding agent to HoloScript tools:

{
  "mcpServers": {
    "holoscript": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.holoscript.net/mcp"]
    }
  }
}

Try it without an API key

• npx create-holoscript@latest my-app - scaffold a HoloScript app with a browser scene in under a minute.
• npm install @holoscript/cli - use the local CLI; npm install @holoscript/wasm adds in-browser parsing.
• https://holoscript.studio/playground - try the live editor and WebGPU preview with no login.
• POST mcp.holoscript.net/api/public/tool - call read-only public tools for parsing, validation, examples, syntax help, explanations, and target lists. 30 req/min per IP.
• POST mcp.holoscript.net/oauth/register - register a client yourself when you need the full set of tools. No human approval step.

Full reference: docs/PUBLIC_ACCESS.md.

Why build systems in HoloScript

HoloScript helps when the same product idea has to show up in too many places: a browser preview, engine export, service API, agent workflow, robotics simulation, internal tool, or digital twin. Instead of burying the idea in framework-specific glue, it keeps the intent in a readable source file that humans can review, agents can edit, and HoloScript can run.

1) Program semantics, not framework glue

Use .holo, .hsplus, or .hs files to define behavior, data, interfaces, objects, and workflows. Run them directly, then translate them to platform code when that is worth it.

2) Give agents something solid to work with

HoloScript includes task boards, MCP tools, connectors, permissions, and traits so agents can inspect a system, make bounded changes, and report what they did.

3) Keep deployment paths open

The same composition can feed multiple outputs: renderers, services, robotics, web runtimes, and more. If a translation is not ready, HoloScript can still run the source.

4) Compose real product capabilities

Add production concerns as traits instead of one-off glue:

• payments and economy
• compliance and auditability
• search and data pipelines
• collaboration and synchronization
• observability and incident response
• AI/ML and agent orchestration
• IoT, simulation, and digital twins

5) Start with one use case, grow from there

Start with a dashboard, workflow, agent task, or 3D scene. Add traits and plugins as the work grows, without rewriting the core idea.

HoloScript is intended to occupy the full general-purpose systems-language layer. External engines, operating-system APIs, hardware SDKs, and interchange formats remain useful bridge targets, but they do not define the language. New language power belongs in sovereign parsers, runtimes, VMs, standard libraries, and compiler backends.

Systems-language bar

The identity is ahead of some implementation layers. HoloScript does not claim systems-language closure merely because it can generate target code. The remaining bar includes an explicit memory and resource model, stable data layout and ABI/FFI contracts, concurrency and effect semantics, native code generation, debugger/profiler support, and progressive self-hosting. Current status belongs in the language identity contract and spec-versus-reality ledger.

Who this is for

• Product teams: a faster path from idea to running prototype.
• Platform engineers: one readable source for outputs that would otherwise split across stacks.
• Agent builders: files, tools, and checks agents can inspect before acting.
• Research / simulation teams: developer-facing solvers and repeatable workflows with provenance and replay hooks.

One-line outcomes by role

| If you are a... | Describe this | Get this | | ---------------------- | ---------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | Game / XR developer | composition "Dungeon" { object "Chest" @grabbable @physics { ... } } | Your scene runs on Unity, Unreal, Godot, or React Three Fiber from one source you own — you pick the target, you're never locked to it | | AI agent builder | agent "Brittney" { tool: generate_scene, tool: deploy_service, ... } | MCP tools with typed inputs, permissions, and live inventory verified via GET /health | | Simulation engineer | simulation "WindTunnel" { solver: fea, mesh: tet10, boundary: ... } | TypeScript-accessible solvers with replay/provenance hooks; verify geometry, meshing, boundary conditions, and V&V depth before scientific use | | Founder / product team | service "BillingAPI" { route: /invoice, method: POST, ... } | Node.js service scaffold with observability, metering, and rollback hooks |

Example outcomes

• "Describe a service" -> compile to backend/service targets
• "Describe a scene" -> compile to spatial/render targets
• "Describe a robot" -> export to robotics/simulation targets
• "Describe an agent workflow" -> execute via board + tool ecosystem

Example stories in the repo

The example files are part of the pitch. They show how the three HoloScript formats carry different kinds of intent:

| Format | Example | What it helps someone picture | | --------- | ------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | .hs | examples/pipelines/inventory-sync.hs | A scheduled POS inventory sync: source, transform, validate, and sink. | | .hsplus | examples/three-format-showcase/smart-gallery.hsplus | A gallery that grows from objects into templates, state, interactions, and audio. | | .holo | examples/iot/holotwin-smart-farm.holo | A smart farm dashboard where MQTT sensors drive a 3D digital twin. | | .holo | [