// SPDX-License-Identifier: CC-BY-SA-4.0
// Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
= The -iser Ecosystem
Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
:toc: left
:toclevels: 3
:icons: font
:source-highlighter: rouge
:url-hub: https://hyperpolymath.github.io/iseriser/
:url-org: https://github.com/hyperpolymath

image:https://img.shields.io/badge/license-PMPL--1.0--or--later-blue[License: PMPL-1.0-or-later,link=LICENSE]
image:https://img.shields.io/badge/Palimpsest-Covenant-purple[Palimpsest Covenant]
image:https://img.shields.io/badge/-iser_family-29_repos-brightgreen[29 repos]
image:https://img.shields.io/badge/ABI-Idris2-red[Idris2 ABI]
image:https://img.shields.io/badge/FFI-Zig-orange[Zig FFI]

[.lead]
**29 Rust CLI tools that inject superpowers from specialist languages into your existing codebase -- without you ever learning those languages.**

{url-hub}[Browse the Hub] | <<the-iser-family,See All 29 -isers>> | <<install,Install>>

'''

== What is the -iser Pattern?

An **-iser** is a Rust CLI that bridges the gap between a _specialist language_
(a language with unique strengths in a narrow domain) and the code you already
write every day. Each -iser:

. **Reads** a declarative TOML manifest describing what you want.
. **Validates** it against a formally verified Idris2 ABI specification.
. **Generates** wrapper code, bindings, or transformations targeting the
   specialist language -- via a Zig FFI bridge for C-ABI compatibility.
. **Builds and runs** the result, giving you the specialist language's
   capabilities without leaving your toolchain.

The pattern lets you tap into GPU kernels (Futhark), formal proofs (Idris2,
Dafny, TLA+), data-race freedom (Pony), fault tolerance (OTP), distributed
computing (Chapel), and 20+ other domains -- all through a consistent
`init / validate / generate / build / run` workflow.

**Iseriser is the meta-framework that generates new -iser projects.** Given a
language description, it scaffolds a complete -iser repo in minutes: manifest
parser, codegen engine, Idris2 ABI definitions, Zig FFI bridge, 17 CI/CD
workflows, RSR governance files, and documentation.

== Architecture: Idris2 ABI + Zig FFI

Every -iser in the family shares a three-layer architecture that guarantees
interface correctness through formal verification:

[literal]
....
                     +---------------------------+
                     |     Rust CLI (cargo)       |
                     |  init/validate/gen/build   |
                     +------+----------+---------+
                            |          |
               +------------+          +------------+
               |                                    |
               v                                    v
  +------------------------+         +------------------------+
  |     Idris2 ABI Layer   |         |   Zig FFI Layer        |
  |  (formal verification) |         |  (C-ABI bridge)        |
  |                        |         |                        |
  |  Types.idr             |-------->|  build.zig             |
  |    dependent types     |  gen'd  |  src/main.zig          |
  |    prove correctness   |   C     |  test/integration.zig  |
  |  Layout.idr            | headers |                        |
  |    memory layout       |         |  zero-cost C interop   |
  |    platform proofs     |         |  cross-compilation     |
  |  Foreign.idr           |         |  no runtime deps       |
  |    FFI declarations    |         |                        |
  +------------------------+         +------------------------+
               |                                    |
               +----------------+-------------------+
                                |
                                v
                   +------------------------+
                   |   Target Language       |
                   |   (Chapel, Futhark,     |
                   |    Idris2, Pony, ...)   |
                   +------------------------+
....

**Why Idris2 for ABI?**::
Dependent types prove interface correctness at compile time. Memory layouts are
verified. Platform-specific ABIs are selected with compile-time proofs. Backward
compatibility is provable. These are type-level guarantees that no other approach
can provide.

**Why Zig for FFI?**::
Native C ABI compatibility with zero overhead. Memory-safe by default.
Cross-compilation is built in. No runtime dependencies. The ideal bridge
between formal specifications and real-world calling conventions.

== [[the-iser-family]]The -iser Family (29 repos)

[cols="3,5,1,1",options="header"]
|===
| Name | Description | Tests | Status

| {url-org}/typedqliser[**TypedQLiser**]
| Add formal type safety (10 levels, dependent/linear/session types) to any query language
| 0
| scaffold

| {url-org}/chapeliser[**Chapeliser**]
| General-purpose Chapel acceleration -- distribute any workload without learning Chapel
| 22
| scaffold

| {url-org}/verisimiser[**Verisimiser**]
| Augment any database with VeriSimDB octad capabilities -- drift, provenance, temporal
| 26
| scaffold

| {url-org}/julianiser[**Julianiser**]
| Auto-wrap Python/R data pipelines into Julia for 100x speedups
| 25
| scaffold

| {url-org}/futharkiser[**Futharkiser**]
| Compile annotated array operations to GPU kernels via Futhark
| 42
| scaffold

| {url-org}/idrisiser[**Idrisiser**]
| Generate proven-correct wrappers from interfaces using Idris2 dependent types
| 6
| scaffold

| {url-org}/tlaiser[**TLAiser**]
| Extract state machines from code and model-check with TLA+/PlusCal
| 32
| scaffold

| {url-org}/dafniser[**Dafniser**]
| Generate correct-by-construction code for critical functions using Dafny
| 28
| scaffold

| {url-org}/ponyiser[**Ponyiser**]
| Wrap concurrent code in Pony reference capabilities for data-race freedom
| 27
| scaffold

| {url-org}/otpiser[**OTPiser**]
| Generate OTP supervision trees and fault-tolerance scaffolding
| 1
| scaffold

| {url-org}/halideiser[**Halideiser**]
| Compile image/video pipelines to optimised Halide schedules
| 24
| scaffold

| {url-org}/lustreiser[**Lustreiser**]
| Generate formally verified real-time embedded code via Lustre
| 36
| scaffold

| {url-org}/bqniser[**BQNiser**]
| Detect array patterns and rewrite as optimised BQN primitives
| 0
| scaffold

| {url-org}/alloyiser[**Alloyiser**]
| Extract formal models from API specs and verify with Alloy
| 25
| scaffold

| {url-org}/atsiser[**ATSiser**]
| Wrap C codebases in ATS linear types for zero-cost memory safety
| 32
| scaffold

| {url-org}/nimiser[**Nimiser**]
| Generate high-performance C libraries via Nim metaprogramming
| 28
| scaffold

| {url-org}/a2mliser[**A2MLiser**]
| Add cryptographic attestation to any markup or configuration via A2ML
| 0
| scaffold

| {url-org}/affinescriptiser[**AffineScriptiser**]
| Wrap code in affine + dependent types targeting WASM via AffineScript
| 36
| scaffold

| {url-org}/anvomidaviser[**Anvomidaviser**]
| Convert ISU notation to formal figure skating programs via Anvomidav
| 36
| scaffold

| {url-org}/betlangiser[**BetLangiser**]
| Add ternary probabilistic modelling to deterministic code via Betlang
| 36
| scaffold

| {url-org}/eclexiaiser[**Eclexiaiser**]
| Add energy/carbon/resource-cost awareness to software via Eclexia
| 23
| scaffold

| {url-org}/ephapaxiser[**Ephapaxiser**]
| Enforce single-use linear type semantics on resources via Ephapax
| 17
| scaffold

| {url-org}/k9iser[**K9iser**]
| Wrap configs into self-validating K9 contracts
| 19
| scaffold

| {url-org}/mylangiser[**MyLangiser**]
| Generate progressive-disclosure interfaces from complex APIs via My-Lang
| 20
| scaffold

| {url-org}/oblibeniser[**Oblibeniser**]
| Make operations reversible and auditable via Oblibeny
| 27
| scaffold

| {url-org}/phronesiser[**Phronesiser**]
| Add provably safe ethical constraints to AI agents via Phronesis
| 31
| scaffold

| {url-org}/wokelangiser[**WokeLangiser**]
| Add consent patterns and accessibility to existing code via WokeLang
| 44
| scaffold

| {url-org}/squeakwell[**SqueakWell**]
| Database recovery through cross-modal constraint propagation -- 8 modalities
| 0
| scaffold

| {url-org}/iseriser[**Iseriser**]
| **This repo** -- the meta-framework that generates all other -isers
| 24
| scaffold

|===

Total tests across the family: **726**

== [[install]]Installation

Every -iser is a standalone Rust binary. Install any of them with:

[source,bash]
----
# Install a specific -iser
cargo install typedqliser
cargo install futharkiser
cargo install chapeliser
# ... or any other -iser name

# Install iseriser (the meta-framework)
cargo install iseriser
----

Or clone and build from source:

[source,bash]
----
git clone https://github.com/hyperpolymath/<name>.git
cd <name>
cargo build --release
----

== Usage

All -isers share the same five-command interface:

[source,bash]
----
# Initialise a new manifest for your project
<iser> init

# Validate your manifest against the Idris2 ABI spec
<iser> validate

# Generate target language code from your manifest
<iser> generate

# Build the generated output
<iser> build

# Run the result
<iser> run
----

== Using Iseriser to Create a New -iser

[source,bash]
----
# 1. Create a language description
cat > mylanguage.toml <<'TOML'
[language]
name = "MyLang"
type_system = ["dependent", "linear"]
target = "native"
calling_convention = "c"
TOML

# 2. Generate the -iser repo
iseriser generate --from mylanguage.toml --output ./mylangiser

# 3. The result is a complete, functional -iser repo
cd mylangiser
cargo test   # tests pass immediately
cargo run -- init
----

== Generated Repo Structure

When iseriser generates a new -iser, it produces:

[source]
----
<name>/
+-- Cargo.toml                        # Rust CLI project
+-- src/
|   +-- main.rs                       # CLI: init/validate/generate/build/run
|   +-- lib.rs                        # Library API
|   +-- manifest/mod.rs               # TOML manifest parser
|   +-- codegen/mod.rs                # Target-specific code generation
|   +-- abi/mod.rs                    # Rust-side ABI types
|   +-- interface/
|       +-- abi/
|       |   +-- Types.idr             # Idris2 type definitions + proofs
|       |   +-- Layout.idr            # Memory layout verification
|       |   +-- Foreign.idr           # FFI function declarations
|       +-- ffi/
|           +-- build.zig             # Zig build config
|           +-- src/main.zig          # Zig FFI implementation
|           +-- test/integration.zig  # FFI integration tests
+-- .github/workflows/                # 17 CI/CD workflows
+-- .machine_readable/                # RSR governance (STATE, META, ECOSYSTEM)
+-- README.adoc
+-- ROADMAP.adoc
+-- TOPOLOGY.md
+-- LICENSE
----

== The Hub

Browse the full -iser family with interactive search and filtering:

**{url-hub}**

The GitHub Pages hub provides:

* Searchable catalogue of all 29 -isers
* Architecture diagrams and domain explanations
* Quick-start guides for each -iser
* Links to crates.io, documentation, and source

== Status

All 29 -iser repos are scaffolded and functional. The architecture is defined,
CLI commands work, manifest parsers are operational, and test suites are in
place across the family. Domain-specific code generation logic is the current
frontier -- each -iser is being deepened with real codegen for its target
language.

== Contributing

See link:CONTRIBUTING.adoc[CONTRIBUTING.adoc] for guidelines. All contributions
must pass the full CI suite including Hypatia neurosymbolic scanning.

== License

SPDX-License-Identifier: `PMPL-1.0-or-later`

Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath)

Licensed under the https://github.com/hyperpolymath/palimpsest-license[Palimpsest License].
