Skip to content

Language Implementation Support

Go is the reference implementation. The normative contract, implementation scope, source tags, and CI coverage are recorded in the language support matrix.

Framework Target

The default target for every independently implemented language is a native Framework implementation of the shared core contract. Wire is an intermediate stage, not a permanent product category. A language remains wire-only as its final scope only when documented language or runtime technical limitations prevent a complete Framework implementation.

An unavailable toolchain, unfinished work, low demand, or an unassigned maintainer is not evidence that a language cannot support Framework behavior. Consumer and maintenance gates control when work starts, not the final target. The target does not imply current availability, a delivery date, every optional Go integration, or production readiness.

Current Stages and Delivery Forms

Type Meaning
Framework (Core) Native framework behavior within the declared public scope, with shared behavior vectors
Wire An intermediate implementation of serialization and declared wire surfaces, progressing toward Framework
Bridge A client of the maintained runtime through a process or HTTP boundary
Sample Usage of an existing language implementation, not another independent runtime

Implementation type is not a stability rating or a promise of every Go feature. C exposes both wire-level JSON primitives and a public Core API. Read each implementation's current public API and limitations before adopting it. Bridge and Sample describe how users access a runtime, not proof that their languages are incapable of Framework support. Shared-runtime languages can reuse the host Framework rather than duplicate its agent loop.

Versions and Distribution

  • The Go core, language Core implementations, adapters, and contract versions are independent.
  • Version tags and maturity are separate: a source tag records a release, while maturity records declared-scope completion and verification.
  • Each Core implementation declares its supported SPEC_VERSION.
  • A source release tag does not establish package-registry availability.
  • Use the installation or source-build instructions on the language page.
  • Python publishes praxo-core==0.2.2 on PyPI. TypeScript publishes @axisvela/praxo-core@0.1.2 on npm.
  • Java documents a Maven source build; Maven Central publication is not established by a source tag.
  • Fortran has source tag fortran/v0.2.0 with all eleven vector groups, native tests, an API snapshot, and integrated PII/middleware. It is not a package-registry release; asynchronous stream support and the bounded JSON Schema subset remain partial.
  • Haskell has source tag haskell/v0.2.0 with all eleven vector groups, native tests, API snapshot/parity, and runtime/middleware helpers. Hackage publication and production readiness are not claimed.
  • Delphi/Free Pascal has source tag delphi/v0.2.1 with all eleven vector groups, native tests, and API snapshot/parity under Free Pascal 3.2.2. The commercial Delphi compiler, other targets, and package registries are not claimed.
  • MATLAB/Octave has source tag matlab/v0.2.1 with all eleven vector groups, native tests, and API snapshot/parity under Octave. The MATLAB runtime, provider adapters, and package registries are not claimed.
  • OCaml has source tag ocaml/v0.2.0 with all eleven vector groups, native tests, and API snapshot/parity. Native ocamlopt compilation, provider adapters, and package registries are not claimed.
  • Elixir, Nim, V, and Objective-C have source tags elixir/v0.1.1, nim/v0.1.1, v/v0.1.1, and objc/v0.1.1. They include all eleven vector groups, native tests, and API snapshots. Package-registry publication, production readiness, and complete Go parity are not claimed; optional Go hooks and provider adapters are not included.
  • Erlang has source tag erlang/v0.1.1 with a native BEAM Core loop, eleven vector groups, native tests, and an API snapshot/parity inventory. Package registries, provider adapters, streaming, and production readiness are not claimed; opt-in middleware is integrated, while optional Go hooks are not included.
  • Lisp has source tag lisp/v0.1.0 for the SBCL bridge over the bridge CLI. It does not provide a native Lisp loop; forwarding, UTF-8, error, and exit-code checks pass locally and in Linux CI. Consumer details and package-registry publication remain pending.
  • Tcl has source tag tcl/v0.1.0 for the Bridge wrapper over the bridge CLI. It does not provide a native Tcl loop; forwarding, UTF-8, error, and exit-code tests pass locally and in Linux CI, while package-registry publication remains pending.
  • Prolog has source tag prolog/v0.1.1 for the SWI-Prolog bridge over the bridge CLI. It does not provide a native Prolog loop; forwarding, UTF-8, error, and exit-code tests pass. Package-registry publication and production readiness are not claimed.

Feature Boundaries

Python, TypeScript, Java, and C# include streaming and an OpenAI-compatible adapter. This does not imply those features exist in every other implementation. Passing shared vectors does not prove complete feature parity with Go, live provider verification, production readiness, or package publication.

VFS backends, plugin hosts, scheduling, and optional integrations must be evaluated against the specific Core's README and API reference.

Contribution Gates

Core changes require the declared vector groups, parity inventory, API checks, and language tests. Wire, Bridge, and Sample implementations have narrower gates. See language policy and Core design. Security-sensitive behavior requires language-specific tests in addition to shared fixtures.