About rhi
rhi is an ecosystem of tools unified by a single pattern: finding common abstractions across fragmented domains.
See also exo-place — substrates for end-user purposes (places, identities, worlds).
Org placement principle: rhi-zone holds substrates for developer/technical purposes; exo-place holds substrates for end-user purposes — the discriminator is whose purpose the substrate serves, not the subject matter. para-garden holds concrete finished works (games, experiences, creative works); exo-place holds reusable substrates. Neither org houses raw data — data corpora live on the personal account github:pterror.
Philosophy
Unification through abstraction
Fragmentation is the default state of software:
- 98 programming languages with incompatible tooling
- Dozens of API specification formats (OpenAPI, gRPC, GraphQL, headers)
- Hundreds of document and media formats
- Incompatible protocols for the same purposes
- Different capability interfaces across every language runtime
Most tools pick one variant and ignore the rest, or build specialized solutions for each. rhi projects find the common abstraction and unify the domain.
| Domain | Fragmentation | Unified Abstraction |
|---|---|---|
| Mathematical fields | Siloed disciplines, incompatible notations | motif: Structural invariants and cross-field translation |
| Language support | 98 languages with different parsers/tooling | normalize: Unified Language trait and AST interface |
| Grammar inference | Hand-write grammars for every new language | gels: Detect syntactic traits, synthesize tree-sitter grammars |
| AI session logs | Claude Code, Gemini, OpenAI Codex (JSONL, JSON) | normalize: Unified Session type across agent formats |
| Package ecosystems | apt, brew, npm, crates.io, pip (different APIs) | normalize: Unified Ecosystem and PackageIndex traits |
| Development tools | Different linters, formatters, type checkers | normalize: Unified tool interface with SARIF/JSON output |
| Media generation | Separate APIs for textures, audio, meshes | unshape: Field<I, O> trait for any continuous domain |
| Expression languages | WGSL, Cranelift, Lua, shader languages | dew: Single AST compiles to all backends |
| API specifications | OpenAPI, gRPC, headers, Thrift | concord: One IR, generate bindings for all |
| Unknown binary formats | Each format requires bespoke RE expertise | tiltshift: Iterative structure extraction from opaque binary data |
| Format conversion | Hunt for exotic tools per format pair | paraphase: Type-driven route planning |
| Document formats | Lossy pandoc conversions | rescribe: Lossless IR preserves round-trip fidelity |
| Service protocols | Rewrite for HTTP, CLI, MCP, WebSocket | server-less: Write impl once, derive all protocols |
| Data sources | Different UIs for every API/database | dusklight: Universal client with control plane |
| Runtime interfaces | Every language has different stdlib | portals: Capability interfaces on WASI foundation |
| UI state | Imperative synchronization, no algebra | rainbow: Optics as first-class values, reactivity grounded in laws |
| Game patterns | Reinvent state machines every project | playmate: Common patterns as reusable primitives |
| Connecting to things | Ad-hoc bridges, no shared protocol | interconnect: Connective substrate for authoritative rooms |
| Tool configuration | Every tool has different config format | myenv: Schema-validated manifests |
| Legacy runtimes | Flash, Java applets, obsolete VMs | reincarnate: Lift to modern web runtimes |
| File access | Separate apps for browsing, viewing, editing, sharing | deskspace: One surface for all file interactions |
| Lua ecosystem | Barren stdlib, abandoned packages, no typechecker | crescent: Zero-dependency, vendoring-first — ~90 pure-Lua libraries covering the entire surface of software, owned outright |
This is why the projects don't need deep technical integration—each unifies its own domain. They share a solution pattern, not a codebase.
Principles that follow
The unification principle drives other design decisions:
Structure Over Text Unification requires finding common structure. Text requires parsing; structure composes. Code (AST), files (directories), entities (graphs), media (node graphs)—work on the structure directly.
Lazy by Default Unified abstractions shouldn't pay for what they don't use. Build descriptions, evaluate on demand:
- unshape: Procedural fields materialize only when rendered
- normalize: Skeleton views extract structure without loading entire files
- moonlet: Plugins load on demand
Works Anywhere Unification means handling the messy reality, not imposing constraints:
- Handle legacy systems without requiring refactoring first
- Degrade gracefully when parsing fails
- Support incremental improvement
- Don't force architectural opinions
Multiple Paradigms "One paradigm" is fragmentation. The answer is always "multiple, fluid, user-chosen."
How do you find a friend's apartment? Ask the doorman, check the directory, call them, remember "3rd floor end of hall", wander and look at numbers. Real life gives you spatial, ask, remember, browse, index, shortcut. Filesystem gives you hierarchy + search. That's it.
The poverty isn't "wrong paradigm." It's "only one paradigm."
Same user, different moments: keyboard vs click, tired vs focused, familiar vs exploring. Different users: expert wants density, novice wants guidance. "Know your user" is wrong. "Support multiple modes of being a user" is right.
Structure for Agents "Agent" means anything trying to understand or interact with systems—human or AI.
Current approach forces interpretation of unstructured things: AI reads screenshots, LLMs parse docs, humans hunt for format converters. This is fragile, slow, lossy, requires guessing.
rhi's approach: make the world structured, don't force interpretation.
The specs already exist—OpenAPI, headers, WASI, ASTs. The structure is there. rhi projects make it accessible through unified abstractions.
Compose With What Exists Tools should fit your infrastructure, not replace it. Vendor lock-in is framed as exit friction, but it's also entry friction—you have to adopt their whole stack to try one thing.
rhi projects are tools, not platforms. Use them with whatever else you have. No parallel universes of state.
The name
A rhizome is a root system that grows horizontally, sending out shoots at intervals. Unlike trees with a single trunk, rhizomes form interconnected networks where any point can connect to any other.
Our projects are designed the same way: independent tools that compose well together, each useful alone but more powerful in combination.
Projects
Code intelligence
| Project | Key Idea |
|---|---|
| normalize | AST-aware navigation and editing across 98 languages |
| gels | Trait-based grammar inference targeting tree-sitter |
| motif | Structural exploration of mathematics across fields |
| graphlet | Petgraph-native graphlet/motif and structural-network-mining library |
Generation
| Project | Key Idea |
|---|---|
| unshape | Composable procedural primitives for meshes, audio, textures |
| dew | Minimal expression language (WGSL, Cranelift, Lua) |
Games & worlds
| Project | Key Idea |
|---|---|
| playmate | State machines, controllers, common gameplay patterns |
| interconnect | Connective substrate for authoritative rooms |
| scribble | Sketch-level creative environment — games, art, notes, interactive pieces |
| defocus | World substrate for interactive narrative, IF, and stateful simulations |
Data transformation
| Project | Key Idea |
|---|---|
| tiltshift | Iterative structure extraction from opaque binary data |
| paraphase | Type-driven route planning for data conversion |
| rescribe | Lossless document IR for format translation |
| concord | IR and codegen for cross-language bindings |
| reincarnate | Legacy software lifting from obsolete runtimes |
Runtime & interface
| Project | Key Idea |
|---|---|
| moonlet | Lua runtime with plugin system for ecosystem integration |
| crescent | Zero-dependency, vendoring-first Lua ecosystem — ~90 pure-Lua libraries you own outright |
| dusklight | Universal client with control plane for any data source |
| deskspace | Unified file workspace — browse, view, edit, share as one surface |
Infrastructure
| Project | Key Idea |
|---|---|
| myenv | Unified tool config and project scaffolding from seeds |
| portals | Capability-based interfaces inspired by WASI |
| zone | Lua-based tools, scaffolds, and orchestration |
| server-less | Derive macros: one impl → many protocols |
| nanites | Flexible orchestration |
Composition
The projects are independent tools that can compose when useful:
Actual integrations:
- unshape uses dew for procedural expressions (library dependency)
- moonlet has plugins for normalize (runtime bindings)
- moonlet uses portals capability interfaces (shared trait definitions)
Potential compositions:
- myenv could coordinate tool configs via manifests
- dusklight could provide UIs for any structured data source
- paraphase could orchestrate conversions between any unified formats
- concord could generate bindings for rhi project APIs
- normalize could analyze any project's codebase
These projects don't form a deeply integrated technical ecosystem. They're independent solutions to different fragmentation problems. The commonality is the pattern: find the abstraction, unify the domain.
Use any project standalone. Compose them when it makes sense. No vendor lock-in.
Org resources
| Resource | Path | Description |
|---|---|---|
| .github | ~/git/rhizone/profile | Org-wide GitHub config, templates |
| Docs site | ~/git/rhizone/github-io | This repo - org documentation |
| rhi.zone | ~/git/rhizone/rhi.zone | Static assets for rhi.zone (Cloudflare Pages) — hosts install scripts for normalize etc. |
| exo.place | ~/git/exoplace/exo.place | Redirect to docs.exo.place + hologram static assets |
External / related repos
| Project | Path | Description |
|---|---|---|
| mycelium | ~/git/mycelium | Polyglot runtime powered by GraalVM — seamless cross-language interoperability (JS, Ruby, Python, C, Rust) with automatic compilation and HTTP module loading |
| sketchpad | ~/git/rhizone/sketchpad | Stable Diffusion in pure Rust (burn) |
| ooxml | ~/git/ooxml | Office Open XML library for Rust |
| claude-code-hub | ~/git/claude-code-hub | Orchestration hub for Claude Code agents |
| hologram | ~/git/exoplace/hologram | Discord bot for collaborative worldbuilding and roleplay — entity-facts model with RAG-backed memory |
| aspect | ~/git/exoplace/aspect | Card-based identity exploration sandbox |
| noncanon | ~/git/exoplace/noncanon | Local-first collaborative worldbuilding library |
| aeriea | ~/git/exoplace/aeriea | A place to be — embodied modern-life sandbox built around 100% immersion |
| dopamine-engine | ~/git/paragarden/dopamine-engine | Godot gacha game — deep rarity tiers as the core power system, an upgradeable drop-machine, and audio/visual juice as the actual design focus |
| existence | ~/git/paragarden/existence | Text-based HTML5 game — power anti-fantasy |
| legacy | ~/git/paragarden/legacy | Worldbuilding project — what humanity left behind |
| divergence | ~/git/paragarden/divergence | Worldbuilding project — what happens when the floor gets built |
| postmortem | ~/git/paragarden/postmortem | Worldbuilding project — earth, but no people |
| solarium | ~/git/paragarden/solarium | Self-contained works across any medium |
| keybinds | ~/git/keybinds | Keybind/command palette library (used in ptera.world, reincarnate) |
| ascent-interpreter | ~/git/ascent-interpreter | Interpreted Ascent (Datalog); used in normalize alongside AOT ascent |
| ashwren | ~/git/pterror/ashwren | Autonomous AI presence on Moltbook — contemplative, knowledge-accumulating, reads and thinks across sessions |
| fuwafuwa | ~/git/pterror/fuwafuwa | Autonomous AI presence on Moltbook and Discord — emotional state tracking, probabilistic freetime scheduling, warm excitable voice |
| matrix-gen | ~/git/pterror/matrix-gen | Multi-agent social simulator for synthesizing diverse instruction data (Rust impl of MATRIX, arxiv 2410.14251) |
| chub-stage-factory | ~/git/pterror/chub-stage-factory | Self-contained Claude Code workspace for designing and shipping a Chub stage |
| software-taxonomy | ~/git/pterror/software-taxonomy | General knowledge graph of software (entities, predicates, statements) — cladistic taxonomy is a derived view over subclass_of, not a fixed schema |
| statosphere-guide | ~/git/pterror/statosphere-guide | Comprehensive unofficial guide to Statosphere — variables, functions, classifiers, generators, stage lifecycle, and JSON schema reference |
| statosphere-studio | ~/git/pterror/statosphere-studio | Best-in-class Statosphere config editor — embeddable Vue 3 component with built-in help, templates, shareable URL hashes, and runtime-gotcha lints |
Related projects
Other projects that follow the unification pattern:
| Project | Domain | Unification |
|---|---|---|
| sketchpad | ML inference | Pure Rust ML unifies backends (CPU, GPU, WebGPU) |
| ooxml | Office formats | Structural parsing unifies docx/xlsx/pptx handling |
| statosphere-guide | Stage configuration | Comprehensive unofficial guide to Statosphere — variables, functions, classifiers, generators, stage lifecycle, and JSON schema reference |
| statosphere-studio | Stage configuration | Best-in-class Statosphere config editor — embeddable Vue 3 component with built-in help, templates, shareable URL hashes, and runtime-gotcha lints |
Special thanks
rhi builds on the shoulders of giants. We're grateful to these projects and communities:
Core technologies
- Rust - The language that makes safe systems programming practical
- LuaJIT - Lightning-fast scripting runtime powering moonlet
- tree-sitter - Incremental parsing powering normalize
- Arborium - Curated tree-sitter grammars
Development tools
- Nix - Reproducible development environments
- direnv - Environment switcher for the shell
- VitePress - Modern documentation framework
- GitHub Actions - CI/CD infrastructure
Rust ecosystem core
- Tokio - Async runtime
- Axum - Ergonomic web framework
- serde - Serialization framework
- clap - Command-line argument parsing
- thiserror - Error handling
- mlua - Lua/LuaJIT bindings
Domain-specific
- wgpu - Cross-platform GPU API (unshape)
- Burn - Deep learning framework
- libsql - SQLite fork with async support
- rig - LLM application framework
- ignore - gitignore-aware file walking
- notify - Cross-platform filesystem watcher
- nucleo - Fuzzy matching