Native Agent Language

Graph-Based IR

JSON/JSONL serialized graphs representing game logic. First-class support for ECS, physics, and shaders.

Semantic Model

Core primitives: Entity, Component, System, PhysicsDomain, MaterialGraph. Declarative rather than imperative.

Multi-Agent System

Specialist fine-tuned SLMs collaborate: ECS Architect, Physics Agent, Shader Agent, Orchestrator.

Verification Framework

Every node includes metadata: created_by_agent, source_intent_id, type annotations. Full lineage tracking.

Bytecode VM

Stack-based virtual machine for hot reload support. Executes NAL in <1 second iterations. JIT compilation via LLVM/Cranelift planned for Phase 4.

Production Tool

Designed for real games, not demos. Planned UE5 integration for AAA workflows.

Not a Text Language

NAL is NOT human-readable code. It's intentionally opaque to maximize semantic density.

Not Replacing Humans

Humans become "semantic engineers" verifying intent, not debugging code. Different role, not eliminated.

Not General Purpose

NAL is game-dev specialized. Optimized for ECS patterns, not web apps or databases.

Entity

Unique node ID representing a game object. Lightweight identifier with no data itself.

{
  "entity_id": "player_001",
  "archetype": "PlayerCharacter"
}

Component

Pure data structures attached to entities. No logic, only state.

{
  "Position": {
    "x": "float",
    "y": "float"
  }
}

System

Pure functions querying and transforming component data. Auto-parallelizable.

{
  "system": "ApplyVelocity",
  "query": ["Position", "Velocity"],
  "transform": "..."
}

PhysicsDomain

Declarative physics properties: constraints, materials, collision rules.

{
  "physics": {
    "gravity": -9.8,
    "friction": 0.3
  }
}

MaterialGraph

Shader graph definitions compiled to HLSL/MSL/SPIR-V.

{
  "material": "PBR",
  "nodes": [...]
}

Metadata

Every node tracks creation agent, source intent, and type information.

{
  "created_by_agent": "ECS_Architect",
  "source_intent_id": "player_v1"
}

Semantic Density

Every token carries maximal semantic information. AI agents can reason about entire game systems within LLM context windows.

Formal Verification

Type systems and constraint checking at compile time. Catch bugs before runtime through static analysis.

Specialist Agents

Fine-tuned SLMs excel in their domain. ECS Architect understands entity patterns. Physics Agent knows constraints.

Graph Visualization

Semantic IDE shows intent graphs, not text. Humans verify "why" not "how". See which agent created each node.

Native Performance

Optimized interpreter runs games at 60fps. LLVM compilation in development for maximum throughput.

Rapid Iteration

Intent → Graph → Compile → Play. Streamlined workflow with no manual coding or boilerplate.

Audit Trail

Full lineage tracking from human intent to compiled code. Every decision traceable to its origin.

ECS-Native

First-class ECS support. Compiler guarantees system purity, data access correctness, and automatic parallelization.

Declarative Physics

Describe physics properties, not implementation. Compiler chooses optimal physics engine and settings.

Orchestrator Agent

Role: Workflow management, task decomposition, agent coordination

Status: Planned for Phase 3 (fine-tuned SLM)

ECS Architect Agent

Role: Entity-Component-System design, archetype optimization

Status: Prototype complete (92% success on test cases)

Physics Agent

Role: Physics simulation, constraint solving, material properties

Status: Planned for Phase 3 (fine-tuned SLM)

Shader Agent

Role: Material graphs, shader compilation, visual effects

Status: Planned for Phase 3 (fine-tuned SLM)

Static Analyzer

Role: Game design validation, balance analysis, performance prediction

Status: Planned for Phase 3 (integrated in Harmonic IDE)

Example Library

Role: Retrieval system for NAL patterns and game templates

Status: 93 examples indexed, expanding in Phase 2-3

✅ Phase 1: Foundation (Months 1-4)

Focus: Stable Resonance Engine

• ✓ JSON/JSONL NAL parser
• ✓ Runtime execution in engine
• ⏳ Example gallery (5+ games)
• ⏳ Documentation & open source launch

📋 Phase 2: ANL Revolution (Months 5-8)

Focus: NAL v2 Compiler + Harmonic Alpha

• ○ NAL v2 syntax (entity, component, system keywords)
• ○ Lexer, parser, AST generation
• ○ Graph IR with optimization passes
• ○ Stack-based VM + bytecode
• ○ Harmonic IDE alpha (Tauri + Monaco)
• ○ Visual node editor (Blueprint-style)
• ○ Hot reload in <1 second

📋 Phase 3: AI-Native Features (Months 9-12)

Focus: Fine-tuned SLMs + Harmonic Beta

• ○ Natural language → NAL (fine-tuned SLM)
• ○ Local AI agents (runs offline, privacy-first)
• ○ Static analyzer (catches design bugs)
• ○ Visual debugger & entity inspector
• ○ Behavior tree DSL & visual editor
• ○ NAL standard library (20+ modules)
• ○ Harmonic Beta launch ($19-49/mo)

📋 Phase 4: Escape Velocity (Months 13-16)

Focus: Production-ready + Marketplace

• ○ NAL VM JIT compilation (LLVM/Cranelift)
• ○ Performance optimization (≥ Bevy speeds)
• ○ Plugin API & marketplace
• ○ Asset store (sprites, sounds, templates)
• ○ Educational content & certification
• ○ Conference talks & press coverage

Local AI Agents

Fine-tuned SLMs run on your machine (no cloud, no API costs). Privacy-first, offline-capable. Generate NAL from natural language descriptions.

Hot Reload

Edit NAL code, save, see changes in <1 second. No game restart. State preserved across reloads. 10x faster than Unity/Godot.

Visual Node Editor

Blueprint-style visual scripting that generates NAL code. Drag-and-drop entities, components, systems. Round-trip: visual ↔ NAL.

Game-Aware Compiler

Catches game design bugs ("Boss HP too high for player DPS"), not just code bugs. Balance analysis, pacing suggestions, performance predictions.

Pricing (Beta Launch)

Indie: $19/mo (1 seat, basic AI)
Studio: $49/mo/seat (5+ seats, advanced AI)
Enterprise: Custom pricing

14-Day Free Trial

Try Harmonic IDE risk-free. No credit card required. Full feature access during trial period. Alpha users get lifetime discounts.