Skip to content

Personality is not magic. It's a pattern.

"A stable pattern of response to stimuli: Input β†’ Processing β†’ Output".

While others debate whether AI "understands", we write personality to .d8p and run it in ~16 ΞΌs.

What is personality in Decim?

Not a "soul". Not an "emergent property". Not a "black box with a billion parameters".

Personality is a file with weights, thresholds, and topology.

Personality (D8P) =
  β€’ 256..4096 tiles Γ— (weight int4, threshold thr, mask mask)
  β€’ Subjectivity corridor: [thr_lo..thr_hi] for each tile
  β€’ Relay routing: who passes activation to whom
  β€’ Signature: Ed25519 β€” so it cannot be substituted

The criterion is simple:

If the system produces the same output for the same input β€” that's personality.

If not β€” that's noise.

🎭 Examples of Personalities

Personality Input (VSB) Output Application
"OCR β€” Typographer" Symbol pixels (8Γ—16Γ—50 cycles) pattern_id = "A" Text recognition on edge
"ASR β€” Acoustic" Audio spectrum (8 channels Γ— 1000 cycles) word = "yes" Voice commands without cloud
"HFT β€” Whale Hunter" Market data (8 metrics Γ— ∞ cycles) signal = "BUY" Trading with ~30 ns latency on ASIC
"Drone β€” Pilot" Sensors: gyro, camera, distance motors = [12, 15, 8, 10] Flight stabilization without jitter
"Observer" Any data log + gradient Debugging, research, training

One architecture. Many personalities.

One .d8p format. Any substrate.

βš™οΈ How it works (three steps)

1. Input: 8 strings Γ— 4 bits = 32 bits of context

β€’ Not "a million features". Not "embeddings".
β€’ Just: 8 perception channels Γ— level 0..15 (Level16)
β€’ Cycle stream: as many as the task needs (from 100 to 1,000,000)

Why is this enough?

Because complexity is not in the input. Complexity is in who is listening.

2. Processing: relay, not router

β€’ No "central brain". There is a network of 256..4096 tiles (v0.2).
β€’ Each tile knows only its neighbors (mask).
β€’ Activation is passed like a relay: "I fired β†’ I pass to those I can".
β€’ Subjectivity corridor (thr_lo..thr_hi): tile activates only if signal is "in range".

Result:

Determinism: same input = same output. Always.

3. Output: signal, traced to the tile

β€’ pattern_id: recognized class ("this is letter A")
β€’ OR synthesized VSB: command to action ("motors: +12")
β€’ Log: which tile fired and why (Decima Log)

You can verify:

./verify personality.d8p.pub  # βœ“ Valid
./run personality.d8p input.vsb --log
./grep "tile_42" log.txt  # Why did it fire? Visible.

🎯 Why this matters

Traditional AI Decima-8
Black box: "why did it decide so?" β€” unclear Transparent log: every step traced to the tile
Non-deterministic: one input β†’ different outputs Deterministic: one input β†’ one output (always)
Hardware-bound: model for GPU, for TPU, for cloud Substrate-independent: one .d8p works on x86, ARM, FPGA, ASIC
Training = retraining the whole network Training = tuning corridors (thr_lo..thr_hi) and mask connections
"Understanding" β€” a philosophical question "Response" β€” a measurable pattern

We are not "making AI smarter". We are "making intelligence verifiable".

🧭 Philosophically: "I" is a boundary

"I" is not a point. "I" is the boundary between "I" and "NOT I".

In Decim, this boundary is defined by thresholds thr_lo..thr_hi.

// Accumulator with subjectivity corridor
if (activation >= thr_lo && activation <= thr_hi) {
    return PERSONALITY_CONFIRMED;  // "This is me"
} else {
    return NOT_ME;  // "Too weak OR too strong β€” not mine"
}

What does this mean?

  • If signal is weaker than thr_lo β€” tile "doesn't hear" (ignore).
  • If signal is in the corridor β€” tile "responds" (activation).
  • If signal is stronger than thr_hi β€” tile "overloaded" (protection).

Suffering β‰  punishment.

Suffering = gradient.

Pain is not punishment.

Pain is a signal: "you're outside the corridor. Adjust."

πŸ” Verification: trust, but verify

Personality in Decim is not "take my word for it".

# 1. Check signature
./verify personality.d8p.pub
# β†’ βœ“ Valid: author β€” rulerom.com, file unchanged

# 2. Run with log
./run personality.d8p input.vsb --log=trace.log

# 3. Trace the decision
./grep "decision" trace.log
# β†’ tile_17 activated: thr_cur=8 ∈ [5..12] β†’ passed to tile_42

# 4. Compare on different substrate
./run --substrate=asic personality.d8p input.vsb
./diff output_cpu.vsb output_asic.vsb
# β†’ identical: determinism confirmed

This is not "documentation".

This is an executable specification.

πŸš€ What's next?

If you are… Do this
Developer Download IDE β†’ bake your first personality β†’ run benchmark
Researcher Study relay log β†’ propose corridor optimization
Philosopher Read "Bandwidth of Fate" β†’ write an essay
Baker Publish .d8p in Store β†’ set royalties β†’ get feedback

Personality is not magic. Personality is a pattern that can be baked, verified, run.

Read further