Hibiki (響き) — Svelte-5-style signals for Ruby

Svelte-5-style signals for Ruby: state, derived, effect.

Hibiki is a fine-grained reactivity library modeled on the signal systems in Svelte 5 and SolidJS. Dependency tracking is done at runtime (not by static AST analysis): while a derived value or effect is computing, it sits on an observer stack, and any signal read during that window subscribes it.

No runtime dependencies. Requires Ruby >= 3.4.

# Gemfile
gem "hibiki"

Or gem install hibiki.

You can use Hibiki in two flavors:

# 1. With DSL
require "hibiki"
include Hibiki::DSL

x = state(0)
y = derived { x.value + 1 }

x.value = 10
y.value # => 11

Or if you wish to avoid using DSL:

# 2. Without DSL
require "hibiki"

x = Hibiki::State.new(0)
y = Hibiki::Derived.new { x.value + 1 }

x.value = 10
y.value # => 11

state(v) — a writable signal. Reading .value registers a dependency; writing notifies subscribers. Writing an ==-equal value is a no-op.

counter = state(0)
counter.value += 1
counter.update { it + 1 } # in-place sugar

derived { } — a lazy computed signal. It recomputes on read when marked dirty (when any state it depends on changes), never on write, and caches its value until a dependency changes.

doubled = derived { counter.value * 2 }
doubled.value # => 4

effect { } — an eager side effect. It runs immediately and re-runs whenever a dependency (any state inside the effect block) changes.

name = state("world")
effect { puts "hello, #{name.value}!" } # prints "hello, world!"

# Effect triggers whenever any of the subscribed values changes
name.value = "Ruby"                     # prints "hello, Ruby!"

Dependencies are re-collected on every recompute, so conditional reads work:

flag = state(true)
a = state("A")
b = state("B")
picked = derived { flag.value ? a.value : b.value }

picked.value        # => "A"
b.value = "B2"      # picked doesn't depend on b right now — no recompute
flag.value = false
picked.value        # => "B2" (deps re-collected)

Svelte 5 allows $state / $derived / $effect as class fields; Hibiki::Reactive is the Ruby analogue. Declare signals with class macros and use them as plain attributes — no more .value in code:

class Counter
  include Hibiki::Reactive

  state :count, 0
  state(:history) { [] }          # block form: fresh default per instance
  derived(:doubled) { count * 2 }
  effect { puts "count is now #{count}" } # starts on Counter.new

  def increment = self.count += 1
end

counter = Counter.new  # prints "count is now 0"
counter.increment      # prints "count is now 1"
counter.doubled        # => 2

Signals are per-instance and created lazily; subclasses inherit all declarations. Use the block form for mutable defaults — a positional default is one object shared by every instance; see Mutable state defaults for the details.

Documentation site: https://planetaska.github.io/hibiki/

More detail in plain markdown: docs-md/

bundle install
bundle exec rake     # specs + rubocop
ruby demo.rb         # quick smoke demo

MIT