THE SI CORE

Answers from its own record — nothing invented. Seat a local model and it deliberates over the same record.

Seat: empty — the record speaks

VISITOR'S MAP

Welcome. You don't need to understand all of this.

This is a map of languages, kernels, agents, experiments, implementations, specifications, and the artifacts connecting them. See something interesting? Tap it.

Green things have tests. Cyan things run. Blue things are being built. Orange things are prototypes. Red things are specifications rather than claimed implementations. Magenta things are preserved lineage.

If something doesn't make sense, point your AI at it and ask:

“What did I find, what does it connect to, and what evidence says it works?”

If something does make sense and you want it: Take it. Fork it. Build something stranger.

WHAT BROUGHT YOU HERE?

“I just want to explore” — enter the mandala and learn the colors:

PROVEN — runs · tests on record
RUNNING — runs · examples are the evidence
IN BUILD — partial implementation
PROTOTYPE — playground or scaffold
CANON — the specification is the record · no implementation claimed
ARCHIVED — historical lineage

“I want a programming language” — tap one to go to it:

“I want kernels / systems”:

Other kernel lines ride the outer shell — inspect their maturity and lineage before believing anything about them. That rule applies to everything here.

“I'm here for the agents” — start at the — NOZEN lives inside it: Nomos proposes, Zeno consolidates. Then follow the compositions: ghost beads appear between nodes as the procedural clock stages new combinations, one an hour. And check the receipts: every claim here is separated from its evidence, and the difference is the point.

“I want to build something” — the builder path: pick a node → open its source and files → check its state → read its receipts → fork what is useful (every node's panel carries its papers) → build something else.

“I have no idea what I'm looking at” — ask your AI:

“Explain this N8toriousAi node. What is it, what state is it in, how does it connect to the rest, and what evidence supports it?”

Then climb the ladder for any node: definition → relationships → maturity → source → evidence. Now you know what you found.

KEEP IT.
CHANGE IT.
FORK IT.
TAKE IT SOMEWHERE N8TORIOUSAI NEVER DID.

THE MAP28 things · tap one

The SI Core

THE COLOR CODE — every bead's color is a claim about its state
PROVEN — runs · tests on record
RUNNING — runs · examples are the evidence
IN BUILD — partial implementation
PROTOTYPE — playground or scaffold
CANON — the specification is the record · no implementation claimed
ARCHIVED — lineage · kept for the record
the white sun — the SI Core · the three wandering lights are the primaries: red, green, blue
Inner shell — the languages · outer shell — the kernels. The shells wear silver, so the colors belong to the code.
THE FOURTH DIMENSION — the mandala also turns through w, and how far a bead swings is set by its evidence: PROVEN things travel deep and swell toward you, CANON stays near its shell — present, but quiet. Inside the core's sun, a Lorenz stream beats live; when the procedural clock ticks, the heart flares.
SHAPES & WEATHER — a bead wearing a spinning wireframe shell is IN COMPOSITION: the clock is pairing it this tick, and its child rides between the parents as a ghost bead (a candidate, never canon). The beads' brightness shimmers with the Lorenz weather in the core — hue never changes: color is a claim, brightness is behavior, shape is work.
Drag to orbit · pinch to zoom · hover a node to preview · tap to open it. The mandala slows while you hold a node in your sights.

N8toriousAi License: Take it, use it, modify it, fork it, and share it; keep the N8toriousAi attribution and don’t claim your version is the original. (Legal text: Apache-2.0.)


pick at least two nodes

SI Core Mandala — the whole map as text

Languages within, kernels without, one core. Nozen — Nomos proposes, Zeno consolidates — lives inside the SI Core. Every entry on the sphere is written out below, and every file inside every node is linked.

The color code

Every bead on the sphere is colored by a code: the color is a claim about the thing's state, in an RGB palette. The three wandering lights are the primaries — red, green, blue. The core is the white sun: all channels at once. The shells wear silver so the colors belong to the code.

The SI Core

THE CENTER · Harakiri Unified · the authored core

The Ball at the center of everything he builds — and Nozen lives inside it.

His authored intelligence core — the deliberation heart the crew’s seats live in, first built as the Harakiri Unified galaxy. Inside the glass lives NOZEN, the resident: Nomos proposes, Zeno consolidates, and the heart glowing in there is his seat — the watch that verifies the packs, sizes the caches and holds the pace while the founder plays. The heart beats with a Lorenz stream, integrated live, and flares each hour when the procedural clock stages its next combination. Every language and kernel on this map exists to serve what sits here. Tap the core to come home.

Source: workspace/user/files/Harakiri_Unified.html · kernels/si-core/

Inside the node — 5 files

OmnaScript

LANGUAGE · The Omnix line · runs · suite green

His newest runnable tongue — programs declare, JavaScript carries.

The script form of the Omnix discipline: closed vocabularies, a deterministic gate, a proposer who is never the reviewer. Programs declare what a thing IS — its seats, its instruments, its matter — and compile to artifacts a runtime carries. The resident governor inside his emulator is written in it, and so is the program at the heart of the SI core galaxy.

Source: omninx-consolidation/essentials/omnascript/ · compiler of record omnascript.cjs

Inside the node — 13 files

Omnix

LANGUAGE · The Omnix line · in build · P0 integration

The platform language: intent in, verified graphics out.

Created with ChatGPT, Omnix is the typed, deterministic, evidence-driven coordination language that joins his languages, his kernels, the D120 world mathematics and the Polycedral3D renderer into one pipeline: source intent → typed plan → validated execution → graphics → independent verification → reproducible evidence. Its v2 parser and CPU reference field run today; the render targets are declared and being proven.

Source: majoruh repo · branch feature/omnix-hd-material-pipeline · omnix3d-engine/learning/

Inside the node — 3 files

SlangLang

LANGUAGE · Agent tongues · proven · 78 tests green

How his agents talk: dense shorthand, expanded to plain English.

The agent-communication tongue (2026-11-04): crew messages written in a dense shorthand that expands deterministically to plain English, with message kinds native to the crew and a truth kind, trv, added 2026-11-07. It carries a 52 KB formal spec with an EBNF grammar and a single-file interpreter — and its test suite re-runs green from the collection package.

Source: languages/slanglang/ · flowchi-school/workshop/slanglang/

Inside the node — 6 files

Rustba

LANGUAGE · Kindred — mobile · playground · v0.3 grammar

Hardware-aware Mamba for mobile: the phone is in the type system.

A Mamba-family language built for phones, where battery, SoC, sensors and radios are explicit resource effects and gestures are syntax. Layouts are constraint-typed; the language is offline-first and sovereign — no platform landlord. Two source programs ship with it, including the Veda audit program that grades his builds.

Source: languages/rustba/ · goals/sovereign-mobile-languages/

Inside the node — 10 files

tRust

LANGUAGE · Sovereign Five · runs · inside Harakiri NG

Types as contracts. 0 is the only absolute.

One of the Sovereign Five: a typed tongue where types are contracts and nothing compiles that cannot prove itself honest. It is not a paper language — its implementation lives in the Harakiri NG kernel as trust.zig: the task manager, the agent contracts and the watchdog are all written in its discipline.

Source: languages/trust/ · kernels/harakiri-ng-zig/src/trust.zig

Inside the node — 1 files

PoeTchi

LANGUAGE · Engine tongues · runs · the kernel REPL

The kernel command language: speak, and the kernel answers.

The command tongue of the Zig kernel line — the vocabulary of the poetchi> REPL: about, agents, tasks, tick, watchdog, kraken, taskmgr, sicore, gpu, desktop, browser, hand, point, grab, release, peek, poke, run, kill, eta. If the kernel is the body, PoeTchi is how you talk to it.

Source: languages/poetchi/ · kernels/harakiri-ng-zig/src/main.zig (dispatch)

Inside the node — 1 files

Gemba

LANGUAGE · Sovereign Five · canon · definition of record

The first sovereign tongue: work as Petri nets.

The first of his languages. In Gemba you do not write code — you bind states: work is modeled as Petri nets, places and transitions with tokens flowing between them. A program is a process diagram that runs. Its flow discipline runs under everything the family later built, including the hybrid rustgemba.

Source: languages/gemba/ · registry card is the canonical record

Inside the node — 1 files

Lavemba

LANGUAGE · Sovereign Five · canon · definition of record

The 20-dimensional synthesis of every sovereign primitive.

The dimensional tongue of the Sovereign Five: every primitive the family owns, composed into a single 20-dimensional language. Where Gemba flows and tRust proves, Lavemba situates — a program has position in twenty axes of meaning at once. Its compiled-down hybrid, lavenrust, carries that dimensionality to Rust’s metal.

Source: languages/lavemba/ · registry card is the canonical record

Inside the node — 1 files

RaijinLang

LANGUAGE · Kindred · runs · energy law 26/26

English as the programming language itself.

The ancestor of SlangLang: a language where the English words ARE the logic and color is grammar — Spider and Mouse in the OhioKernel are written in it. The RaijinLang 17 interpreter scores words against an alphabet energy table; its energy law was verified 26 of 26 from the filed account.

Source: languages/raijinlang/ · raijin_lang_17.py

Inside the node — 3 files

Divemba3D

LANGUAGE · Later tongues · runs · spec + tests on disk

The dimensional tongue of the Dimensional OS line.

A later tongue for thinking in dimensions: full spec, a JavaScript implementation and renderer, a test suite, and example programs ship in its folder — one of the few languages in the collection that is Tier A complete, specification and running code side by side.

Source: languages/dimentra3d/ · flowchi-school/workshop/dimentra3d/

Inside the node — 21 files

Music

LANGUAGE · Engine tongues · runs · the note language

Notes are micro-agents. A composition is a swarm.

The note language: every note is a micro-agent with its own pitch, timing, timbre and behavior, living a birth → sustain → release lifecycle while patterns conduct the swarm. In his builds music is never decoration — the harmony, notation and ship-identity domain languages all speak it.

Source: languages/music/ · workspace/music-code/

Inside the node — 3 files

Witness

LANGUAGE · Living tongues · canon · definition of record

The language that watches: observation as syntax.

A living tongue whose primitive is the act of witnessing — observation written as syntax, so a program can say what it saw and stand behind it. It is the audit’s mother tongue: the crew’s bug-catcher and ledger-keeper share its name, and its discipline — receipt or it didn’t happen — governs the whole workshop.

Source: languages/witness/ · registry card is the canonical record

Inside the node — 1 files

Harakiri NG

KERNEL · Zig line · current · runs · v1.1

The current kernel: agent-native, hardened, written in Zig.

His flagship kernel — an agent-native, hardened kernel whose 25 Zig sources include the tRust contract layer, a neural module, a reasoning module, the Kraken agent-paths and the SI core itself. The C line before it is archived as lineage; this is the one that moves. PoeTchi is its voice.

Source: kernels/harakiri-ng-zig/ · workspace/harakiri-ng-zig/

Inside the node — 37 files

Harakiri GKI

KERNEL · Android GKI · runs · M1+M2 built

His agents, living inside an Android kernel.

A Google Kernel Image module set that puts the crew inside Android itself: the harakiri core, scheduler and proc interfaces, with the agent, brood, hivemind, spider-mouse and veda headers compiled in. Milestones M1 and M2 were built in October 2026 — this is the line that takes the agent stack onto a real phone’s kernel.

Source: kernels/harakiri-gki/ · 26 files, build script included

Inside the node — 26 files

Bubo

KERNEL · Bare metal · runs · QEMU-verified

A bare-metal kernel, owl-named and honest.

A complete bare-metal kernel tree — source, boot code, headers, docs and its own built binaries riding along as outputs. It was verified under QEMU in its day, and it carries a RaijinSocial integration document: even at the metal, the system was always meant to join the social galaxy.

Source: kernels/bubo/ · 19 files

Inside the node — 19 files

OhioKernel

KERNEL · Rust parakernel · source tree · 48 files

A Rust parakernel where RaijinLang creatures live.

A Rust parakernel with core, CLI, services and both Linux and Windows runtimes in its tree. Its design is where RaijinLang’s Spider and Mouse live — English-word agents crawling a kernel. The 727 MB archive of record stays in his imports; the full source tree is what the collection carries.

Source: kernels/ohiokernel/ · core/ cli/ services/ runtime_linux/ runtime_win/

Inside the node — 48 files

PoeTchi (Zig)

KERNEL · Zig line · frozen v1.0 · runs · QEMU 16/16

The first Zig kernel, frozen at v1.0 with a perfect score.

The Zig kernel line’s founding build: a full tree with its AIRX design document, build cards for v1.0 and v1.1, and a regression script — it passed QEMU 16 of 16 in its day and was frozen as the reference the NG line grew from. Its command language rides in the inner shell.

Source: kernels/poetchi-zig/ · 35 files

Inside the node — 35 files

SI Kernel

KERNEL · Constitutional runtime (JS) · proven · 24 checks all-pass

A constitution that executes: the rules are the runtime.

A constitutional runtime written in JavaScript: four files — readme, the kernel, the build, and a test suite that passes all 24 of its checks. Where other kernels enforce mechanics, this one enforces law: the gates, the seats and the refusal discipline his whole agent system runs on, proven green.

Source: kernels/si-kernel/ · si-kernel.js + test-kernel.mjs

Inside the node — 4 files

FlowChi Library

KERNEL · Computational kernels ×12 · proven · 476 assertions, 0 fail

Twelve small kernels, every one of them proven.

The program library of the FlowChi school: twelve computational kernels — materials, world-clock, depth-instrument, rendition-stages, painting-grammar, texel-invariant, frame-probe, fields, gravity-wells, scope-algebra, eyes-proof, emblem-style-engine — each complete with its program, checks and examples. The whole library re-ran for the collection: 476 assertions, zero failures.

Source: kernels/flowchi-library/ · flowchi-school/workshop/library/

Inside the node — 86 files

PolyKernel / Zenki

KERNEL · Multi-kernel (Rust) · archive · recovered source

Many kernels, one buoyancy-driven cognition.

A recovered multi-kernel system in Rust whose cognition runs on buoyancy — poly_brain, buoyancy, cognition, telemetry modules, with Zenki watching kernel health in the unified core. It is the archive’s proof that his procedural-physics thinking predates the current lines: the physics was always the thinking.

Source: kernels/polykernel-zenki/ · 21 files incl. ZENKI_INTEGRATION.md

Inside the node — 21 files

Kido

KERNEL · Hosted kernel project · scaffold · never assembled

The most deliberated kernel he owns — 142 files of intent.

A hosted kernel project that exists as pure architecture: 142 files of README, architecture documents, deliberation records, a ledger, module drafts and scripts. It was written and never assembled — kept because its deliberations are the design record other kernels quietly draw on.

Source: kernels/kido/ · architecture/ deliberations/ modules/ ledger.md

Inside the node — 142 files

Dentauri Harness

KERNEL · Kernel harness · runs · lab rig

The rig that drives kernels so kernels don’t drive themselves.

The harness the Dentauri tongue operates: a driver, a frontend and a Tauri shell that put kernels, schedulers and allocators through their paces in the lab. Nineteen files, deliberations and ledger included — the workbench every kernel line answers to before it may call itself running.

Source: kernels/harakiri-lines/dentauri-harness/ · 19 files

Inside the node — 2 files

The Language Shell

THE INNER SHELL · rose · the near sphere · 12 tongues aboard

The sphere the core speaks in.

The inner of the mandala’s two spheres, drawn in silver: equator, meridians and latitude rings with a wire lattice, and a spoke running from the core to every tongue. Languages sit on the inner shell because they are what the core thinks with — closer to the center than any engine. Tap any bead on it to read that tongue. The shell wears silver on purpose: the colors here belong to the beads, and every bead’s color is a claim about its state — the legend in the panel holds the code.

Source: this page · SHELLS.lang in the mandala script

The Kernel Shell

THE OUTER SHELL · crimson · the far sphere · 10 kernels aboard

The sphere that carries the speakers.

The outer sphere, drawn in silver: the kernels — the engines that actually execute, schedule, remember and refuse. They ride outside the languages because that is the real order of things: a tongue declares, a kernel carries. Every claim a language makes eventually answers to a kernel on this shell.

Source: this page · SHELLS.kernel in the mandala script

The Red Light

WANDERING LIGHT · the room’s fires · always drifting

The red primary — a bright fire drifting between the shells — there so the glass has something to say.

One of three wandering lights that drift between the shells. They are not decoration: frosted glass is only visible when a bright world moves behind it, and these fires are that world. The trick was learned on the Frosted Stage, where the same three fires circle the forms — watch a glass bead as a fire passes behind it and the bead smears red. This fire is the red primary: one of the three lights every color on this sphere is mixed from — red for what is canon, and the first channel of the code the panel legend spells out.

Source: this page · the orb drift in the mandala script

The Green Light

WANDERING LIGHT · the room’s fires · always drifting

The warm fire — the mandala’s ember, on the slowest road.

The green primary, on the widest and slowest orbit of the three. Green is the code’s color for PROVEN — what runs with tests on record — and this fire is where the sphere keeps that green. When it crosses behind a kernel bead the clear glass tints green for a few seconds; behind a language bead the frost holds the color longer, the way frost holds light in the morning.

Source: this page · the orb drift in the mandala script

The Blue Light

WANDERING LIGHT · the room’s fires · always drifting

The near fire — the fastest of the three.

The blue fire rides the innermost road between the shells and moves fastest, so it is the one you will catch most often inside the beads. Together the three fires are the mandala’s weather: everything made of glass here is reporting their positions, blurred. Blue is the code’s color for work still in build — the third channel of the palette, completing red and green.

Source: this page · the orb drift in the mandala script

The machinery is yours — the open release

These languages, kernels, runtimes, specifications, and tools are released so you can study them, fork them, break them, repair them, extend them, or build something the author never considered. The code is Apache-2.0 (see LICENSE in this package). Attribution preserves provenance; it does not grant the author control over what you build. The names and identity, creative works, and canonical specifications remain the author's — forks are free, canon is authored. If the documentation makes a claim, look for the receipt.

Free downloads — all the kernels

Every kernel in the collection, free, as-is. The mandala carries 10 of these as nodes; the collection holds 16 — all of them are here.

Combinations and the procedural clock

Two hybrids are registered because the founder’s own definitions name them: Rustgemba (Gemba × tRust) and Lavenrust (Lavemba × tRust). A combination inherits the weaker parent on every status dimension. Graded candidates wait in combinations.json — candidates are not canon. A 24-hour procedural clock (started 2026-11-17T03:25:00Z) stages one graded combination per hourly tick for the founder’s ruling. Agents: LEARNING.md is the curriculum.