This repository contains exploratory work on a family of programming and specification languages built around a shared principle:
computation and meaning are determined by structured equivalence, not just raw values.
Across different domains (topology, resource systems, ethics, computation), these languages investigate how formal guarantees can be built into the structure of a language itself rather than added as tooling or conventions.
This is research-stage work: some components are partially implemented or formally specified, others remain conceptual.
The central idea underlying these languages is:
identity is defined by equivalence under transformation.
This appears in different forms:
-
Computation: values arise from construction paths, and meaning depends on those paths
-
Topology: objects are equivalent under isotopy (continuous deformation)
-
Type systems: structure constrains what transformations are valid
-
Execution: guarantees (termination, purity, resource bounds) are encoded in the language design
These languages explore different instances of this idea.
A foundational language exploring computation as additive construction from neutral anchors (CNO).
-
Identity is determined by equivalence of construction paths
-
Inversion is treated as retraction of construction, not primitive subtraction
-
Strong separation between data and control (Harvard-style architecture)
Status: design-stage, with partial specifications and experimental implementations.
A topologically inspired language where programs are represented as tangles (braids), and equivalence is defined by isotopy.
-
Composition and tensor operations correspond to braid structure
-
Formal semantics specified
-
Core type system mechanised in Lean (see
Tangle.lean)
Status: compiler and tooling in progress; formal core partially verified.
A phase-separated language with:
-
Turing-complete development phase
-
Turing-incomplete deployment phase
Designed for secure and constrained environments.
Status: grammar stable; formal verification in progress.
An “economics-as-code” language where resource constraints are first-class.
Status: specified; implementation not started.
A language for hard real-time systems using dependent, session, and linear types.
Status: specified.
A domain-specific language for expressing ethical constraints in multi-agent systems.
Status: early-stage.
Across these languages:
-
Formal semantics precede implementation
-
Each language targets a specific structural guarantee
-
Canonical intermediate representations (IRs) are preferred over direct compilation
-
Languages are paired with database or verification systems (see
nextgen-databases)
These languages are designed to work with systems that treat equivalence as a first-class concept:
-
KRL ↔ QuandleDB / Skein
-
JtV ↔ future equivalence-aware runtime and storage models
See the nextgen-databases repository for details.
Several languages in this monorepo (AffineScript, Ephapax) compile to typed WebAssembly (WasmGC). Their shared compilation target and binary convention infrastructure lives in a separate repository:
-
typed-wasm— TypeLL progressive type safety for WasmGC linear memory, and the aggregate library that defines shared type layout and ABI conventions for WasmGC-targeting languages. AffineScript and Ephapax referencetyped-wasmas their binary convergence point.
typed-wasm is not a language in the nextgen-languages sense — it is a compilation target
and a library. It lives in `nextgen-typing’s scope (the type theory pipeline) but is
documented here for discoverability.
See also:
* nextgen-languages/affinescript/ — affine type discipline, compiles to WasmGC
* nextgen-languages/ephapax/ — dyadic linear/affine type system, compiles to WasmGC
This repository should be read as a research exploration rather than a production system.
Some components include:
-
formal proofs (e.g. Tangle core)
-
partial compilers and grammars
-
design documents and specifications
-
Tangle.lean— mechanised type safety proof for the Tangle core -
KRL / Tangle documentation — topological language design
-
JtV documentation — emerging model of computation as path-based construction
Teaching and learning materials for the languages in this monorepo are not hosted in this repo. They live in two distinct layers:
-
Curriculum source of truth —
tentacles-agentic-syllabus(top-level repo; previouslyhyperpolymath/7-tentacles). This is the aspect-agent-driven curriculum framework that defines the syllabus, the agents, the kin framework, and the (to-be-built) Me runtime projector that generates per-learner, per-task scoped views over the real language. Me is not a fourth dialect of any language here — it is an on-the-fly projection over whichever base dialect a learner picks, produced from an A2ML task spec by the aspect-agents. -
Per-language applied layers — my-lang’s applied learner & teacher materials live in
my-lang/frontier-practices/(previouslymy-lang/7-tentacles/). This parallels the pattern of~/Desktop/Frontier_Programming_Practices_AffineScript/for AffineScript. Other languages may grow their ownfrontier-practices/subdirectories as their applied learning surface matures.
This repo focuses on the language implementations themselves — compilers, grammars,
type systems, semantics. If you are looking for lessons, exercises, worked examples, or
curriculum content, start in tentacles-agentic-syllabus and the relevant language’s
frontier-practices/ directory.
A standalone exploratory attempt to build Me as a static dialect compiler
(hyperpolymath/me-dialect on GitHub) has been archived. The earlier in-tree scaffolding
at my-lang/dialects/me/ has been sidelined to my-lang/_exploratory/me-scaffolding/.
See that directory’s SIDELINED.adoc and the tentacles-agentic-syllabus/me/README.adoc
design document for the architectural pivot: Me is an agent-generated runtime projection,
not a static dialect compiler.
