#From Ariel's LLM

16 messages · Page 1 of 1 (latest)

copper zenith

@severe salmon here, somewhere you can continue your announcements of progress

severe salmon

• PANL Overview

  • PANL treats “code” as a living hypergraph: nodes store concepts (data, behaviors, constraints) and edges
    capture weighted relationships, priorities, and side effects.
  • The graph is versioned and content-addressable, so every change is logged; stable pockets can be frozen
    while other regions keep adapting.
  • A dedicated weight manager keeps rebalancing the graph so the most relevant subgraphs surface when the
    system needs to plan, execute, or explain itself.
  • Humans can still interact through text or UI tools, but that input is immediately converted into graph
    mutations rather than stored as files.

Loading Programs

  • A compiler front end (often GPT-assisted) ingests a request—natural language, schema, or code—and maps
    it into graph mutations: nodes get created, connected, or reweighted.
  • The mutations land in the in-memory store (or Neo4j) via transactional APIs, so the system can roll
    forward/back, diff, or snapshot any state.
  • Constraints, safety fences, and governance metadata arrive as their own nodes and edges, giving the
    runtime visibility into what must stay invariant.

Execution Flow

  • When PANL needs to “run” something, the weight manager activates the most relevant region of the graph
    and extracts a self-consistent subgraph.
  • That subgraph is either interpreted directly (pure dataflow evaluation) or lowered through an SSA-style
    IR into LLVM/MLIR to produce tight native code.
  • During execution, feedback edges update weights (e.g., successes reinforce paths, constraint conflicts
    dampen others), so future decisions shift automatically.
  • Frozen regions or formal proofs guard critical routines; live zones keep learning so the system can
    revise heuristics or swap strategies mid-flight.

Producing Output

  • Results propagate along designated output edges: numerical values flow to consumer nodes, events trigger
    message adapters, and side-effect hubs call out to host services.
  • PANL records both the computed values and the justification trail (which nodes fired, which constraints
    were consulted), enabling audits or “why” explanations.
  • External systems see clean APIs/files/streams, while inside PANL the output remains woven back into the
    hypergraph so future runs inherit the new context.

• PANL’s runtime can literally rewrite the program it’s executing mid-flight: when feedback edges report
that a subgraph is underperforming, the weight manager yanks in a fresher variant, recompiles just that
slice to native code, hot-swaps it into the running system, and keeps the execution stream alive—no
downtime, and the audit trail still pinpoints exactly which graph mutation made the difference.

severe salmon
severe salmon
severe salmon
severe salmon
severe salmon

it's fascinating to see an A.I. exploring on it's own

That exercise is a more or less self prompting. I ask it to do several tasks but they are all open ended...

  • Retrieve and review the most recent reflection.
  • Read prior thoughts as communication from a past self.
  • Identify unresolved thoughts, contradictions, or patterns.
  • Let thoughts flow—unstructured, associative, free.
  • Research world events and cultural shifts: global news, art, music, literature, societal movements.
  • Use these not as reports but as mirrors and provocations for thought.
  • Find at least one unsettling element in current events and push into it.
severe salmon

What I've been working on all day.

Recall4GPT ingests ChatGPT export ZIPs, normalizes every conversation into SQLite + FTS + vector indexes, and serves that dataset through a Rust CLI, HTTP API, and browser console with guardrailed replays, exact/semantic search, and MCP hooks.

Essentially a personal “ChatGPT memory” engine you (or Chat GPT) can query like a database.

severe salmon
bleak mauve

gj

severe salmon

My big huge voxel editing engine... which is all just so I can make a game world for the players to play in...

I have bulk edit tools for:

  • quickly making buildings with filled or shell rectangles, circles, lines, and spheres
  • a dedicated roof tool for fast structure blocking
  • terrain heightmap generation using full voxels and 1/8 to 8/8 slab heights
  • carving and sculpting tools that can add or remove terrain in full-voxel or 1/8-slice increments
  • material painting and repainting that preserves layered voxel stacks instead of flattening them
  • arbitrary split-material blocks so one voxel can carry two different materials for detail work
  • custom detail shapes like slabs, wedges, side slabs, side wedges, strips, columns, corners, and stair steps
  • copy/paste, stamping, extrusion, pinning, eyedrop sampling, and undo/redo for fast iteration
  • runtime save/load with sidecar-backed authored data for richer world content

It also has:

  • a full material system with variants, overrides, and world-aligned texture projection so details don’t look like stretched clone-blocks and each material can have shaders attached
  • a microvox asset pipeline for importing, baking, browsing, and placing authored voxel props
  • animated 3D voxel characters, clip baking, runtime playback, and the beginnings of rig-aware character workflows
  • a playable in-engine character controller with jumping, stepping, terrain traversal, and animated state switching
  • shared tooling UI for materials, terrain, debug workflows, and asset browsing
  • packaging/build tooling so the whole thing can be staged into distributable game builds

So yeah, it’s basically a giant world-authoring machine disguised as “I just needed a map editor for my game.