Skip to route content
Hara
Implemented

Hara programming language

Hara is a programming language built from readable forms.

A form is a Hara data structure that can represent code or data and can be inspected before evaluation. Explicit runtimes evaluate or lower forms on browser Wasm, JVM, and Rust hosts; libraries, capabilities, revisions, and results remain named at those boundaries.

Read and run a form Compare benchmark results Read the language model
www.narrative-page sha256:www-family-issue-38 3 reference records
formsreadable code and data
runtimeexplicit evaluation host
recordsrevision and method
packagesversioned namespaces
Language unit Readable forms

Code and data share an inspectable representation.

Runtime hosts Wasm · JVM · Rust

Each executable surface names its host and capabilities.

Library model Namespaces and packages

Public symbols resolve to versioned, maintained records.

Evidence record Revision and method

Measurements and results name their source and context.

01 · First form

Read the source, note the runtime boundary, then evaluate it.

The form remains readable documentation before a runtime is attached. Evaluation is a separate state with a named backend, session, capabilities, source revision, and expected result.

Definition

A form represents code or data

The source can be read, copied, transformed, or checked without executing it.

Runtime

Evaluation has an explicit host

The example identifies its Wasm session and denies network and filesystem access.

Result

Input and output remain beside each other

Run the bounded example or open the exact revision in the Playground.

First form · browser Wasm example

first-system.hal

Runtime ready
Runtime
Wasm · isolated
Session
www-first-01
Generation
1
Revision
hara@9b6c10e + wasm@7ae1
pureportable-formsnetwork:nonefilesystem:none
first-system.hal Static source · executable only when ready 
;; static source is readable before a runtime attaches
(defn describe [system]
  {:language :hara
   :runtime  (runtime/name system)
   :portable (runtime/capability? system :portable-forms)
   :result   (map inc [1 2 3])})

(describe *session*)

The runtime is attached. Running creates a new fenced execution receipt.

Result 
Ready to run.

02 · Language and runtime model

Four boundaries organise the introductory reference.

Forms, libraries and tools, runtime sessions, and host interop are described as concrete language or system contracts. Each section points to the corresponding source, package, specification, or runtime record.

01

portability

Forms can be interpreted, lowered, generated, or hosted.

The authored form remains available for inspection while an explicit runtime chooses how to evaluate or translate it.

  • Browser Wasm sessions
  • JVM and Truffle hosts
  • Rust-native lowering
  • Generated target code
Reference record

Representative source revisions are attached to runtime and benchmark records.

02

tooling

Libraries and tools use ordinary Hara values.

Filesystem, compiler, lint, migration, work, package, and deployment interfaces compose through named namespaces and data values.

  • std.lib.* foundations
  • tool.lint facts
  • code.migrate ledger
  • work algebra
Reference record

Namespace references resolve to packages and exact releases.

03

runtimes

Executable examples identify their runtime session.

A session is one runtime context with an identity, backend, generation, capabilities, and an explicit unavailable or degraded state.

  • Isolated sessions
  • Shared groups
  • Capability fencing
  • Execution receipts
Reference record

The documentation specimen keeps static source separate from executable runtime state.

04

interop

Host interop is represented at an explicit boundary.

Host values, native interfaces, package coordinates, and generated outputs retain their source and ownership information.

  • JVM libraries
  • Rust native ABI
  • JavaScript hosts
  • PostgreSQL and service tooling
Reference record

References point to package, namespace, specification, and evidence records.

03 · Projects and records

Language concepts connect to maintained packages and source.

The map identifies the main parts of Hara. The project records then name concrete packages, repositories, specifications, and revisions rather than using an undifferentiated list of features.

01

Language

Forms and semantics

Evaluation, macros, namespaces, schemas, and portable code.

02

Runtime

Sessions and execution

Wasm, JVM, Rust, native interfaces, and explicit capabilities.

03

Library

Reusable systems

std.lib.*, std.work, code.*, tool.*, and packageable facilities.

04

Records

Specifications and measurements

Conformance, benchmarks, exact revisions, and reproducibility receipts.

05

Community

World and Learn

Articles, discussions, examples, curriculum, packages, and contributor records.

std.workDurable work algebra

Replayable work, checkpointed steps, stores, executors, and explicit capability boundaries.

hara-wasm-coreBrowser runtime kernel

Isolated and shared sessions with source revision, generation, and runtime status exposed.

tool.lintFact-oriented analysis

Unresolved symbols, type facts, arity, schema mismatches, and source locations as inspectable output.

code.migrateDeterministic source migration

A governing ledger for generated publication, compatibility dispositions, and reproducible regeneration.

04 · Recent changes

Each change names its scope, effect, and revision.

This summary links language, runtime, content, migration, and compatibility questions to their detailed records in Docs and Packages.

Runtime

Session controls become a shared interface contract

Docs and Playground can expose the same lifecycle states.

rev:runtime-ui-88
Content

Front matter registry reaches seven route families

Overview, Docs, and Benchmarks now consume shared typed metadata.

rev:content-428e
Language

Schema becomes a first-class typed primitive

Reference, checking, lint, and publication can share one semantic boundary.

rev:schema-71c4

Learn

Study the language in sequence

Continue from the first form into concepts, exercises, projects, and curriculum revisions.

Read Learn

World

Read community work and discussion

Read articles, clippings, discussions, package changes, and owner-attributed bot contributions.

Read World

05 · Run or install

Choose a browser, local, or repository-guided path.

The three paths are alternatives. Each states its runtime assumptions and the source or verification record to inspect before continuing.

01

Browser

Run the first form

Use a capability-fenced Wasm session and inspect the exact source revision before running.

Open the runnable example
Open this path →
02

Local CLI

Install Hara locally

Create a local project, run the REPL, and select a JVM or native host explicitly.

brew install hara-lang/tap/hara
Open this path →
03

Repository guide

Use an agent to inspect the repository

Require exact files, implementation status, and a verification command before running an example.

Read the Hara repository and suggest a verified first example
Open this path →

06 · First arrival and unavailable states

Static language material remains readable without the runtime.

Source and explanation remain available during runtime failure, constrained bandwidth, small-screen use, or anonymous reading. Disabled actions state why they are unavailable.

Live example unavailable

The Wasm runtime could not attach

The source, capability contract, expected result, and exact revision remain visible. Run is disabled and retry is bounded.

  • Static documentation retained
  • Open-in-Playground remains revision-pinned
  • No inferred result

Low-bandwidth request

Text and records load before runtime assets

The header field becomes a quiet placeholder, executable code remains plain text, and large runtime payloads wait for a deliberate action.

  • Core HTML first
  • No autoplay shader
  • Runtime download is opt-in

Anonymous reader

Reading and local execution do not require an account

Sign-in is used for saved sessions, progress, subscriptions, and publication; it is not required for the language overview.

  • Search available
  • Examples available
  • Receipts remain local until saved

07 · Desktop, tablet, and mobile specimens

The reading order remains stable as the layout changes.

These specimens record navigation reduction, source and revision visibility, and the point at which executable controls move into a deliberate drawer.

Desktop · 1440px

Definition, form, and reference records remain adjacent
Hara

Readable forms and explicit runtimes.

DefineRunReference
Four language-model sections follow

Tablet · 900px

Family routes remain; records become two columns
Hara / Overview

Readable forms and explicit runtimes.

DefineRun
References remain next in reading order

Mobile · 390px

Text first; runtime opt-in
Hara

Readable forms and explicit runtimes.

Run first formRuntime and revision remain directly below

08 · Ownership and adoption

The reference separates shared presentation from authoritative data.

This route is an interface specimen. A public Hara site replaces fixture data and providers while preserving the readable order, explicit runtime state, and source and evidence links.

LayerOwnsSource
Shared visual languageTheme, tokens, buttons, fields, tables, badges, tool chrome, responsive primitivessrc/v2.css + src/astro/v2/*
Shared content contractSchema namespaces, required fields, controlled facts, exact revision, evidence and receiptssite/src/lib/v2-frontmatter.mjs
Hara public siteFamily header, local navigation, overview ordering, docs reading shell, benchmark evidence compositionsite/src/components/v2-www/*
Downstream implementationProduction data, authentication, search index, runtime provider, benchmark registry and canonical domainshara-www / hara-docs / hara-benchmarks

Downstream implementation

hara-www

Consume
WwwFamilyHeader · WwwSubnav · hara.www contracts · overview reading order
Replace
Fixture release feed · Fixture package records · Example runtime adapter
Preserve
Definition → example → reference hierarchy and unavailable runtime state.

Downstream implementation

hara-docs

Consume
Docs reading shell · LiveHaraExample · hara.docs contracts · state specimens
Replace
Static search results · Static API symbols · Fixture version selector
Preserve
Prose remains primary; executable examples are bounded and revision-pinned.

Downstream implementation

hara-benchmarks

Consume
Result-summary ordering · Evidence matrix · selected-result ledger · hara.benchmarks contracts
Replace
All numeric fixtures · Evidence files · Comparison review state
Preserve
Every result exposes method, environment, samples, baseline, revision, and comparability.