Nengo + Jneopallium Integration: Smooth Spiking Vectors Meet Heterogeneous Multi-Timescale Signal Processing!

Hey HF community,Big news for anyone building biologically plausible, production-grade spiking systems: the official peer-to-peer bridge between Nengo and Jneopallium is now ready.While Nengo gives you elegant, mathematically grounded vector encoding/decoding with the Neural Engineering Framework and Semantic Pointer Architecture, Jneopallium brings something unique that no other framework offers at this level:

Heterogeneous signal processing + per-signal processing speeds.

Every signal in Jneopallium is a first-class typed object that declares its own ProcessingFrequency(loop, epoch). The framework runs a dual fast/slow loop scheduler that naturally creates five distinct biological timescales (spike-level → PSP summation → neuromodulator integration → memory consolidation → circadian) — all without manual timing hacks. Different neurons can respond to the same signal type in completely different ways (multi-receptor architecture), and entirely different signal types can coexist in the same layer with their own propagation rules.This is the main advantage of Jneopallium: it lets you model real cognitive heterogeneity and multi-timescale dynamics structurally, not as an afterthought.The new bridge makes the two frameworks complementary peers instead of competitors:

• Nengo side: continuous vector encoding of sensors, smooth spiking ensembles, biologically plausible motor decoding (the part Nengo already does better than anyone).

• Jneopallium side: typed-signal safety authority (HarmGateNeuron, explicit interlocks), heterogeneous multi-receptor neurons, per-signal timescale scheduling, planning, transparency logs, and immutable audit trail.

They synchronize through a tiny, well-defined JSONL frame schema over Unix domain sockets (or files for deterministic replay). Jneopallium remains the single safety source of truth — Nengo never gets to bypass the harm veto or safety mode.Why this combination is powerfulPure Nengo is smooth and flexible but lacks structural safety and native multi-timescale heterogeneity. Pure Jneopallium gives you auditable, heterogeneous, multi-timescale cognition but doesn’t have Nengo’s vector-decoding elegance. Hybrid = both.You get:

• Nengo ensembles encoding sensor vectors → Jneopallium typed signals (each with its own frequency)

• Heterogeneous neurons processing those signals at the biologically correct timescale

• Full Jneopallium safety pipeline (planning → HarmGate → per-tag SHADOW/ADVISORY/AUTONOMOUS)

• Approved MotorCommandSignal → back to Nengo for smooth synaptic-filtered motor output

Minimal production-like config (UDS mode)

yaml

transport:
  channelInPath: "/tmp/jneo-nengo-input.sock"
  channelOutPath: "/tmp/jneo-nengo-output.sock"
  mode: UDS

simulatorOnly: true

inputMappings:
  - frameLabel: "dx_target"    signal: SENSORY  modality: "GOAL_RELATIVE"
  - frameLabel: "obstacle_dx"  signal: SENSORY  modality: "PROXIMITY"
  - frameLabel: "human_risk"   signal: HARM_ASSESSMENT
  # ... more sensors (each becomes a typed signal with its own frequency)

outputMappings:
  - approvedSignalType: "MotorCommandSignal"
    frameLabels: ["vx", "vy"]
    validForMs: 250
    failSafeFrame: { safety_status: "STOP", values: {vx: 0.0, vy: 0.0} }

perTagSafetyMode:
  ROBOT.MOTOR: ADVISORY   # start in SHADOW for safe observation

Quick start

1. Add the Jneopallium worker artifact (Maven coords in the manual).

2. Wire the seven bridge classes (full bootstrap example in the manual).

3. cd worker/src/test/python/nengo && pip install -r requirements.txt

4. Run the bundled nengo_input_model.py + nengo_output_model.py (or your own ensembles).

The Python demo already encodes a 6-D sensor vector through a 600-neuron ensemble and decodes motor commands through a 400-neuron smoothing ensemble — perfect starting point.Full manual (attached in the original thread or in the repo) covers wiring, frame schema, safety algorithm, audit trail, operating procedures, and how to add new sensor channels or approved signal types.This integration is still v1.0-SNAPSHOT but already production-ready for simulators and advisory control. The safety contract is deliberately strict — Jneopallium stays in charge.If you care about spiking networks that are both smooth (Nengo) and heterogeneously multi-timescale + auditable (Jneopallium), this is the combo you’ve been waiting for.Would love to hear from the Nengo, neuromorphic, safe-RL, and cognitive-modeling crowds:

• What would you encode in Nengo ensembles vs. keep as native typed signals in Jneopallium?

• Any interesting multi-timescale use cases you want to try?

Drop questions, ideas, or your hybrid experiments below

Repo / Maven coords + full manual in the Jneopallium Nengo Integration thread (or GitLab packages).

• GitHub: https://github.com/rakovpublic/jneopallium

• GitLab mirror + Maven packages: https://gitlab.com/rakovpublic/jneopallium License: BSD 3-Clause.Looking forward to seeing what the HF community builds!— Dmytro Rakovskyi (Jneopallium author)