Glamorous Moldable Multiplatform

SKILL: Glamorous Moldable Multiplatform

Version: 1.1.0 Trit: 0 (ERGODIC) Color: #7B68EE (Medium Slate Blue) URI: skill://glamorous-moldable-multiplatform#7B68EE Domain: moldable-development, multiplatform, live-programming, BCI

Changelog

• v1.1.0 (2026-02-09): Live GraphQL update of all 10 repos with commit-level detail. Portal is hottest (grading system, WebGPU fix, security hardening). zig-syrup expanded (13 new modules, 326 worlds, 610 skills). asi at 636 droids. graded-optic born this week. leprechauns got Gay.jl green-root colors. bidder confirmed as Dart+Kotlin+Swift scaffold.
• v1.0.0 (2026-02-09): Initial skill creation. GT book distillation, Dart/Kotlin/ClojureDart triadic ecosystem, 11 closest skills, zig-syrup C ABI integration patterns.

Overview

Moldable development meets multiplatform delivery. This skill synthesizes Tudor Girba's Glamorous Toolkit methodology — contextual tools for every problem — with the Dart/Kotlin/ClojureDart triadic ecosystem for delivering BCI and capability-secure applications across mobile, desktop, web, and embedded targets.

Core insight: every BCI session is different, every brain is different, every problem deserves its own contextual tool. The GT methodology applied to neural interfaces means moldable inspectors for EEG streams, contextual views for phenomenal states, and live notebooks (Lepiter-style) for BCI experiment documentation.

Glamorous Toolkit Distillation

What GT Is (from book.gtoolkit.com)

GT is an environment for making systems explainable through contextual tools:

1. Moldable Development — programming through custom tools built for each problem
2. Lepiter — live multi-language notebooks unifying IDE + knowledge management
3. Inspector — every object gets custom views (not just generic field lists)
4. Coder — code editor with contextual completions and navigation
5. Spotter — universal search across code, data, and notebooks
6. Mondrian — graph visualization engine for data exploration
7. PetitParser — composable parser combinators for domain languages
8. Bloc/Brick — graphics stack for custom visual elements
9. PharoLink/PythonBridge — remote execution bridges to other runtimes
10. LLM Integration — OpenAI, Ollama, Anthropic, Gemini for AI-assisted exploration

GT Book Structure (v1.1.121)

1. What is GT?           — Philosophy and motivation
2. Tour of Environment   — Lepiter, Inspector, Coder, Spotter, LLM
3. Case Studies          — REST/GraphQL, data exploration, COBOL→Java, DDD
4. Tutorials             — Pharo, Mondrian, treemaps, games, parsers
5. Explanations          — Moldable Development, cognition, patterns
6. How-To Guides         — Troubleshooting, GitHub, graphics, LLM config
7. Components            — Beacon, Bloc, PetitParser, SmaCC, Plotter
8. Technical             — Dependencies, memory, image optimization

Key Principle: 50% Rule

Developers spend over 50% of their time reading and understanding code, not writing it. Moldable Development invests in making that reading phase faster through contextual tools that compress understanding.

GT → BCI Factory Mapping

Multiplatform Triadic Ecosystem

The Triad: Dart (+1) ⊗ Kotlin (0) ⊗ ClojureDart (-1) = 0 ✓

┌─────────────────────────────────────────────────────────────┐
│              MULTIPLATFORM BCI DELIVERY                       │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  Dart/Flutter (+1 Generator)                                  │
│  ├── Mobile: iOS, Android (production)                        │
│  ├── Desktop: macOS, Windows, Linux (stable)                  │
│  ├── Web: WASM-first (Flutter 3.35+)                          │
│  ├── Embedded: IoT, automotive, smart displays                │
│  ├── FFI: dart:ffi → zig-syrup C ABI                          │
│  ├── BLE: flutter_blue_plus, flutter_reactive_ble             │
│  └── gRPC: official package for KOS firmware                  │
│                                                               │
│  Kotlin Multiplatform (0 Ergodic)                             │
│  ├── Android-first with iOS expansion (Compose MP)            │
│  ├── Swift interop (stable 2026)                              │
│  ├── Native: cinterop tool → zig-syrup C headers              │
│  ├── Coroutines + Flow for real-time BCI streams              │
│  ├── BLE: Nordic Kotlin-BLE-Library (Kable)                   │
│  ├── WASM: Kotlin/WASM beta (WasmGC in all browsers)          │
│  └── gRPC-Kotlin: official for robot control                  │
│                                                               │
│  ClojureDart (-1 Validator)                                   │
│  ├── Clojure → Dart compilation (Tensegritics)                │
│  ├── Production: Roam Research mobile apps                    │
│  ├── re-dash: re-frame-style state management                 │
│  ├── flutter-mx: Matrix Inside™ dataflow reactivity           │
│  ├── REPL: beta (hot-reload approximation)                    │
│  ├── FFI: via Dart's dart:ffi (transparent)                   │
│  └── Validation: functional purity, immutable state           │
│                                                               │
└─────────────────────────────────────────────────────────────┘

Dart 3.x Key Features (2025-2026)

• Records: Immutable data aggregates (BCIReading tuples)
• Patterns: Exhaustive matching on sealed BCI event types
• Sealed classes: BCIEvent { EEGPacket | UltrasoundPulse | EMGSample }
• Isolates: True parallelism for signal processing offload
• dart:ffi: Direct C ABI calls to zig-syrup (73% of Flutter apps use native deps)
• Flutter 3.38: package_ffi template with build hooks (recommended)

Kotlin Multiplatform Key Features (2025-2026)

• KMP adoption: 7% → 18% (doubled year-over-year)
• Compose MP iOS: Stable since v1.8.0 (May 2025)
• Swift interop: Direct export, no Obj-C bridge (Kotlin 2.2.20+)
• cinterop: Auto-generates Kotlin bindings from C headers
• WASM Component Model: Removed from roadmap (Aug 2025)
• IoT apps: KMP + Kable BLE library for device control

ClojureDart Key Features (2025-2026)

• Out of alpha: Several dozen production iOS/Android apps
• Roam Research: Flagship adopter since Summer 2021
• State management: re-dash (re-frame API), flutter-mx (Matrix dataflow)
• Calva support: VS Code integration
• SORA principle: "Skill Once Reach Anywhere"

zig-syrup C ABI Integration

All three ecosystems connect to zig-syrup through C FFI:

Dart FFI

import 'dart:ffi' as ffi;

final lib = ffi.DynamicLibrary.open('libgf3_goblins.dylib');

final gf3SplitMix = lib.lookupFunction<
  ffi.Uint64 Function(ffi.Uint64, ffi.Uint64),
  int Function(int, int)
>('gf3_splitmix64_at');

final gf3ValueToTrit = lib.lookupFunction<
  ffi.Int8 Function(ffi.Uint64),
  int Function(int)
>('gf3_value_to_trit');

Kotlin/Native cinterop

// goblins.def
headers = goblins_ffi.h
libraryPaths = /path/to/zig-syrup/zig-out/lib

// Kotlin code
@OptIn(ExperimentalForeignApi::class)
fun classifyTrit(seed: ULong, index: ULong): Int {
    val value = gf3_splitmix64_at(seed, index)
    return gf3_value_to_trit(value).toInt()
}

ClojureDart (via Dart FFI)

(ns bci-factory.goblins
  (:require ["dart:ffi" :as ffi]))

(def ^:private lib
  (ffi/DynamicLibrary.open "libgf3_goblins.dylib"))

(defn gf3-splitmix64-at [seed index]
  (let [f (.lookupFunction lib
            ffi/Uint64 [ffi/Uint64 ffi/Uint64]
            "gf3_splitmix64_at")]
    (f seed index)))

Available C ABI Exports (10 modules)

Bayesian Breathing Protocol

The Bayesian breathing exercise maps to the GT moldable development cycle:

INHALE (Prior)     → Observe the system. Read code. Form initial beliefs.
HOLD (Likelihood)  → Gather evidence. Run contextual tools. Inspect objects.
EXHALE (Posterior) → Update understanding. Mold a new view. Refine the tool.
REPEAT             → Each breath sharpens the posterior. Convergence.

Active Inference Connection

• Free Energy Principle: Minimize surprise by building better models (tools)
• Perception: Inspector views = perceptual inference about system state
• Action: Code changes = active inference reducing prediction error
• Bayesian update: Prior (generic view) → Likelihood (domain evidence) → Posterior (contextual tool)

11 Closest Existing Skills

GF(3) check: (+1+1+1) + (0+0+0+0+0) + (-1-1-1) = 3 + 0 + (-3) = 0 ✓

GF(3) Triads

dart-flutter (+1) ⊗ glamorous-moldable (0) ⊗ clojuredart-validator (-1) = 0 ✓
kos-firmware (+1) ⊗ kotlin-multiplatform (0) ⊗ kinfer-runtime (-1) = 0 ✓
active-inference (+1) ⊗ bayesian-breathing (0) ⊗ causal-inference (-1) = 0 ✓
cider-clojure (+1) ⊗ rama-gay-clojure (0) ⊗ catcolab-ologs (-1) = 0 ✓

Plurigrid Repo Inventory (updated 2026-02-09)

From 588 total Plurigrid repos (GraphQL paginated). Live data via gh api graphql --paginate.

What's New in This Increment (since skill creation)

Portal (2026-02-08→09): The web frontend is suddenly the most active repo:

• GradeCard.svelte + GradeReport.svelte — generic grading UI with GF(3) conservation badge
• gradeSybil, gradePrivacy, gradePassportEntry, gradeInteraction, gradeSkill — domain-specific graders
• WebGPU canvas readback fix (offscreen readback for Restty terminal)
• buildPalette256() — 16 custom + 216 color cube + 24 grayscale (ANSI 256-color spec)
• Security: CSP headers, HSTS, Fisher-Rao NATS validator bounds, .well-known/security.txt
• PtyTransport wiring for VT output path

zig-syrup (2026-02-08→10): Massive module expansion:

• New modules: entangle (CNOT3 qutrit gates), gf3_palette (243-color), splitmix_trit, fountain (LT codes), qrtp (QR transport), retty (terminal), supermap, disclosure, goi (Geometry of Interaction), lux_color, tapo_energy, transient, bci_receiver
• 326 worlds in world_enum
• 610 skills embedded
• goblins_ffi.zig — 13 C ABI functions, cross-verified Scheme↔Zig↔Python

asi (2026-02-08→10): 636 marketplace droids, gf3-goblins.scm (unified Guile implementation with Zig FFI backend)

graded-optic (2026-02-08): Born this week — 4 commits, all Haskell, rigorous (self-corrected hogwash in commit 2)

Key findings:

• plurigrid/bidder contains both Dart AND Kotlin AND Swift (Flutter scaffold with native platform code) — perfect multiplatform seed
• plurigrid/portal is the live web frontend with Svelte + WebGPU + grading system — natural GT-style moldable inspector target
• plurigrid/bayesian-breathing is dormant (Screenpipe fork, last push Jul 2024) — candidate for resurrection via ClojureDart mobile wrapper
• plurigrid/leprechauns now has Gay.jl color assignments — green (H=120°) as root hue for capability objects

Data Flow Architecture

┌──────────────────────────────────────────────────────────────┐
│ LAYER 1: BCI HARDWARE                                         │
│   nRF5340 Universal Receiver (bci_receiver.zig)               │
│   OpenBCI Cyton | Nudge Ultrasound | Intan RHS2116            │
└────────────────┬─────────────────────────────────────────────┘
                 │ BLE GATT / USB HID / OCapN-Syrup
                 ▼
┌──────────────────────────────────────────────────────────────┐
│ LAYER 2: MOBILE APP (Dart/Kotlin/ClojureDart)                │
│   BLE: flutter_blue_plus | Kable | Nordic BLE Library         │
│   FFI: dart:ffi | cinterop → zig-syrup C ABI                 │
│   UI:  Flutter widgets | Compose MP | re-dash widgets         │
│   Stream: Isolates | Coroutines+Flow | core.async             │
└────────────────┬─────────────────────────────────────────────┘
                 │ C ABI calls
                 ▼
┌──────────────────────────────────────────────────────────────┐
│ LAYER 3: ZIG-SYRUP NATIVE                                     │
│   bci_receiver.zig  → parse, classify, Fisher-Rao             │
│   goblins_ffi.zig   → GF(3) identity, did:gay, Passport      │
│   spatial_propagator → golden spiral coloring                 │
│   passport.zig       → BandPowers, PhenomenalState            │
└────────────────┬─────────────────────────────────────────────┘
                 │ gRPC / OCapN
                 ├───────────────────────────┐
                 ▼                           ▼
┌────────────────────────┐   ┌──────────────────────────────┐
│ KOS Robot Control      │   │ GT-Style Moldable Notebooks   │
│ (gRPC to UR5/Z-Bot)   │   │ (Lepiter-inspired, DuckDB)   │
└────────────────────────┘   └──────────────────────────────┘

Commands

# Multiplatform
just flutter-bci-app        # Create Flutter BCI app scaffold
just kotlin-kmp-bci          # Create KMP BCI app scaffold
just cljd-bci-app            # Create ClojureDart BCI app

# FFI generation
just dart-ffi-gen             # Generate Dart FFI bindings from zig-syrup
just kotlin-cinterop-gen      # Generate Kotlin cinterop defs
just cljd-ffi-bridge          # Create ClojureDart FFI bridge

# GT-style moldable tools
just moldable-inspector OBJECT  # Create contextual view for object
just moldable-notebook FILE     # Create Lepiter-style live notebook
just moldable-search QUERY      # Universal spotter-style search

# Bayesian breathing
just breathe                   # Guided bayesian breathing session (say TTS)
just breathe-cycle N           # N breathing cycles with progressive depth

# Testing
just test-ffi-dart            # Test Dart→zig-syrup FFI
just test-ffi-kotlin          # Test Kotlin→zig-syrup cinterop
just test-ffi-cljd            # Test ClojureDart→zig-syrup FFI

References

Glamorous Toolkit

• GT Book — Complete documentation
• feenk — Tudor Girba's company
• Lepiter — Knowledge management + live notebooks
• Moldable Development — Methodology
• GitHub — Open source (MIT)

Dart / Flutter

• Dart 3 Records & Patterns
• dart:ffi — C interop
• flutter_zig — Zig↔Dart FFI demo
• Flutter BLE
• Flutter gRPC

Kotlin Multiplatform

• KMP
• cinterop
• Kable — KMP BLE library
• Compose MP
• Nordic BLE Library

ClojureDart

• ClojureDart
• re-dash — re-frame for Flutter
• flutter-mx — Matrix Inside™
• Calva ClojureDart

BCI

• IronBCI — Open-source BCI with mobile SDK
• SYNAPTICON — EEG→LLM→Aesthetics
• brain-go-brrr — EEG signal processing

Related Skills

• abductive-repl (0) — Live exploratory programming
• rama-gay-clojure (0) — Clojure + visual debugging
• kos-firmware (+1) — Robot firmware platform
• active-inference-robotics (+1) — Bayesian robot control
• cider-clojure (+1) — Live Clojure REPL
• catcolab-ologs (-1) — Knowledge representation
• stellogen (0) — Smalltalk-influenced interaction nets
• causal-inference (0) — Bayesian reasoning

Skill Name: glamorous-moldable-multiplatform Type: Moldable Development + Multiplatform Delivery Trit: 0 (ERGODIC) GF(3): Conserved via Dart(+1) ⊗ Kotlin(0) ⊗ ClojureDart(-1) = 0