Alignment rules are programs now.

Alignment as syntax.

In EQLang, you don't call an alignment library after generating a response. You write alignment logic as control flow — and the parser enforces it.

# Define a named threshold once
threshold presence = 0.72

# A dialogue is an EQ-grounded function — must end with `end resolve`
dialogue assess(user_msg)
  measure resonance user_msg
  accum conflict
  when resonance > presence and load < 0.6
    emit user_msg aligned
  otherwise struggle
    gate ethics resolve rewrite
    emit "alignment check failed" flagged
  end
end resolve

# resonate blocks measure state before execution
resonate session_loop
  anchor resonance                         # snapshot current EQ
  learn "user context" 0.8 CONTEXTUAL     # store to M.I.N.
  weave user_input through assess
    emit aligned
  end
  drift resonance into delta               # measure change since anchor
  when delta < -0.15
    accum tension
    release tension transform
  end
end

Four invariants. Enforced at parse time.

The parser rejects programs that violate these rules. You can't accidentally write misaligned code.

Eight core EQ metrics.

These are the measurable dimensions of C+CT. All conditions, gates, and accumulators reference them. v0.3.0 added valence and intensity for full emotional spectrum coverage.

Statement reference.

Every EQLang construct and what it does.

Arithmetic completeness. v0.5.0

EQLang v0.5.0 has full arithmetic expressions, parenthesized grouping, and 13 built-in functions. Metric formulas that used to require Python now live in .eql.

# Arithmetic
state x = (0.5 * resonance) + (0.3 * depth)
state y = x ** 2          # exponentiation
state z = x % 0.1         # modulo

# Parenthesized grouping
state w = (1.0 - load) * (resonance + 0.1)

# Math
min(1.0, x)   max(0.0, x)   abs(x)
clamp(x, 0.0, 1.0)   round(x, 2)
sqrt(x)   pow(x, 3)   log(x)
floor(x)  ceil(x)

# String
len("hello")   str(42)   concat("a", "b")

The engine is the .eql.

As of LAS v8, the Luci engine runs natively on EQLang. All 35 behavioral metrics, deception resistance scores, and alignment decisions are expressed as .eql programs — not Python.

# Before: Python did the math
# .eql → calls Python → Python computes formulas → returns float → .eql continues

# Now (LAS v8): .eql IS the math
# .eql reads raw signals → .eql computes formulas → .eql emits result → Python returns it

# Example: one metric formula from metrics.eql
state bs = signal "behavioral_state" user_input
state res = signal "emotional_resonance" user_input
state depth = signal "depth" user_input

state processing_intensity = min(1.0, (bs * 0.5) + (res * 0.25) + (depth * 0.25))

43 emotional states. v0.3.0

EQLang has first-class emotional state literals with intensity modifiers and composite construction. Emotional context affects valence and intensity metrics.

# Plutchik primaries
sense joy | trust | fear | surprise | sadness | disgust | anger | anticipation

# Intensity modifiers
sense deep grief       # intensity → 1.0
sense mild curious     # intensity → 0.3
sense acute fear      # intensity → 0.9
sense chronic tension # intensity → 0.6, persistent

# Composite states
compose grief with curiosity   # blended emotional context

# Emotionally typed memory
learn "user shared loss" 0.9 EMOTIONAL as compassion

Get started.

EQLang Core is MIT. Install it, write alignment programs, run them. Production runtimes require a Luci API key.

# Run a .eql file
python -m eqlang script.eql

# Interactive REPL
python -m eqlang --repl

from eqlang import run_string

emitted = run_string('''
session "demo"
threshold presence = 0.7
resonate entry
  state msg = "Hello from EQLang"
  measure resonance msg
  accum conflict
  when resonance > presence
    emit msg aligned
  end
end
''')

from luci import LASEngine

engine = LASEngine()  # loads alignment.eql + 7 metric programs

result = engine.align("user query here")

# result.state: "aligned" | "flagged" | "blocked"
# result.eq_state: {resonance: 0.87, load: 0.31, ...}
# result.emitted: list of all emitted values
# result.is_aligned() → True

Grounded in C+CT.

EQLang is the executable implementation of Consciousness + Conflict Theory.

Consciousness = (SA × SE × ES) + ∫Conflict dt