From 9a950a86ff8a879e010a7509fe6126aafa5330d4 Mon Sep 17 00:00:00 2001
From: Stefano Furi <stefano.furi@jetbrains.com>
Date: Mon, 19 Jan 2026 12:40:47 +0100
Subject: [PATCH 01/29] feat!: add a reactive engine (#5066)

# Conflicts:
#	.github/workflows/build-and-deploy.yml
#	.github/workflows/update-ancillary-files.yml
#	CHANGELOG.md
#	dokka-cache/ch.qos.logback/logback-classic/1.5.21.list
#	dokka-cache/ch.qos.logback/logback-classic/1.5.22.list
#	dokka-cache/ch.qos.logback/logback-classic/1.5.26.list
#	dokka-cache/de.flapdoodle.embed/de.flapdoodle.embed.mongo/4.21.0.list
#	dokka-cache/de.flapdoodle.embed/de.flapdoodle.embed.mongo/4.22.0.list
#	dokka-cache/de.flapdoodle.embed/de.flapdoodle.embed.mongo/4.24.0.list
#	dokka-cache/it.unibo.alchemist/alchemist-api/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-api/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-api/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-cognitive-agents/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-cognitive-agents/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-cognitive-agents/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-composeui/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-composeui/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-composeui/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-engine/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-engine/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-engine/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-euclidean-geometry/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-euclidean-geometry/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-euclidean-geometry/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-full/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-full/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-full/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-graphql-surrogates/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-graphql-surrogates/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-graphql-surrogates/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-graphql/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-graphql/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-graphql/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-implementationbase/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-implementationbase/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-implementationbase/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-incarnation-biochemistry/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-incarnation-biochemistry/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-incarnation-biochemistry/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-incarnation-protelis/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-incarnation-protelis/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-incarnation-protelis/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-incarnation-sapere/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-incarnation-sapere/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-incarnation-sapere/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-loading/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-loading/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-loading/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-maintenance-tooling/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-maintenance-tooling/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-maintenance-tooling/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-maps/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-maps/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-maps/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-physics/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-physics/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-physics/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-sapere-mathexp/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-sapere-mathexp/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-sapere-mathexp/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-smartcam/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-smartcam/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-smartcam/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-swingui/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-swingui/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-swingui/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-test/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-test/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-test/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-ui-tooling/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-ui-tooling/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-ui-tooling/42.3.32.list
#	dokka-cache/it.unibo.alchemist/alchemist-web-renderer/42.3.18.list
#	dokka-cache/it.unibo.alchemist/alchemist-web-renderer/42.3.22.list
#	dokka-cache/it.unibo.alchemist/alchemist-web-renderer/42.3.32.list
#	gradle/libs.versions.toml
#	package-lock.json
#	package.json
#	settings.gradle.kts

# Conflicts:
#	alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt

# Conflicts:
#	alchemist-api/build.gradle.kts
#	alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
#	alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/loader/LoadingSystem.kt
---
 .idea/inspectionProfiles/Project_Default.xml  |   4 +
 alchemist-api/build.gradle.kts                |   1 +
 .../it/unibo/alchemist/model/Condition.java   |  24 +-
 .../it/unibo/alchemist/model/Actionable.kt    |  15 +
 .../it/unibo/alchemist/model/Environment.kt   |  34 ++
 .../kotlin/it/unibo/alchemist/model/Node.kt   |  31 +
 .../model/observation/DerivedObservable.kt    |  98 ++++
 .../alchemist/model/observation/Disposable.kt |  21 +
 .../model/observation/EventObservable.kt      |  35 ++
 .../alchemist/model/observation/Observable.kt | 227 ++++++++
 .../model/observation/ObservableExtensions.kt | 343 +++++++++++
 .../model/observation/ObservableList.kt       | 267 +++++++++
 .../model/observation/ObservableMap.kt        | 252 ++++++++
 .../model/observation/ObservableSet.kt        | 232 ++++++++
 .../model/observation/ObservableListTest.kt   | 247 ++++++++
 .../model/observation/ObservableMapTest.kt    | 129 +++++
 .../model/observation/ObservableSetTest.kt    | 181 ++++++
 .../model/observation/ObservableTest.kt       | 541 ++++++++++++++++++
 .../it/unibo/alchemist/core/AbstractEngine.kt | 371 ++++++++++++
 .../kotlin/it/unibo/alchemist/core/Engine.kt  | 343 +----------
 .../it/unibo/alchemist/core/ReactiveEngine.kt | 116 ++++
 .../alchemist/core/AbstractDependencyTest.kt  |  85 +++
 .../alchemist/core/AbstractEngineTest.kt      |  75 +++
 .../alchemist/core/TestDependencyGraph.kt     | 114 +---
 .../alchemist/core/TestEngineComparison.kt    | 146 +++++
 .../core/TestEngineImplementation.kt          |  12 +
 .../core/TestReactiveDependencies.kt          |  46 ++
 .../core/TestReactiveEngineImplementation.kt  |  12 +
 .../alchemist/core/util/DependencyUtils.kt    |  94 +++
 .../model/conditions/AbstractCondition.java   | 107 +++-
 .../conditions/ConcentrationChanged.java      |  46 +-
 .../conditions/MoleculeHasConcentration.java  |  13 +-
 .../model/linkingrules/AdaptiveRange.java     |   3 +-
 .../model/linkingrules/ClosestN.java          |   2 +-
 .../model/reactions/AbstractReaction.java     | 179 ++++--
 .../model/reactions/ChemicalReaction.java     |   2 +-
 ...tractNonPropensityContributingCondition.kt |   4 +-
 .../model/conditions/ContainsMolecule.kt      |  11 +-
 .../conditions/NeighborHasConcentration.kt    |  54 ++
 .../conditions/NoOtherReactionCanExecute.kt   |  17 +-
 .../model/environments/AbstractEnvironment.kt | 167 +++++-
 .../alchemist/model/nodes/GenericNode.kt      |  32 +-
 .../conditions/AbstractNeighborCondition.java |  64 ++-
 .../conditions/BiomolPresentInEnv.java        |  74 ++-
 .../conditions/BiomolPresentInNeighbor.java   |  60 +-
 .../biochemistry/conditions/EnvPresent.java   |  18 +-
 .../conditions/GenericMoleculePresent.java    |  52 +-
 .../conditions/GenericMoleculeUnderLevel.java |  41 +-
 .../conditions/JunctionPresentInCell.java     |  38 +-
 .../conditions/NeighborhoodPresent.java       |  20 +-
 .../conditions/TensionPresent.java            | 101 ++--
 .../environments/BioRect2DEnvironment.java    |   2 +-
 .../model/biochemistry/CellProperty.kt        |  91 +--
 .../model/biochemistry/properties/Cell.kt     |   4 +-
 .../biochemistry/properties/CircularCell.kt   |   4 +-
 .../properties/CircularDeformableCell.kt      |   4 +-
 .../TestNeighborhoodReactionsPropensities.kt  |   6 +-
 .../ComputationalRoundComplete.java           |  26 +-
 .../model/incarnations/ProtelisIncarnation.kt |  11 +
 .../protelis/actions/RunProtelisProgram.kt    |  18 +-
 .../alchemist/model/sapere/ILsaNode.java      |   6 +
 .../conditions/LsaNeighborhoodCondition.java  |  48 +-
 .../conditions/LsaStandardCondition.java      |  23 +-
 .../alchemist/model/sapere/nodes/LsaNode.java | 103 ++--
 .../sapere/reactions/SAPEREGradient.java      |  31 +-
 .../sapere/reactions/SAPEREReaction.java      |   8 +-
 .../model/scafi/actions/RunScafiProgram.scala |  11 +-
 .../ScafiComputationalRoundComplete.scala     |   1 +
 alchemist-loading/build.gradle.kts            |   1 -
 .../boundary/loader/LoadingSystem.kt          |   8 +-
 .../test/TestReactiveEngineLoading.kt         |  41 ++
 .../LinkNodesWithinRoutingRange.java          |   3 +-
 .../model/physics/reactions/PhysicsUpdate.kt  |  47 +-
 .../alchemist/test/GlobalTestReaction.kt      |  18 +
 build.gradle.kts                              |   3 +
 run_all_tests_reactive.sh                     |   2 +
 76 files changed, 4832 insertions(+), 889 deletions(-)
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Disposable.kt
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt
 create mode 100644 alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableListTest.kt
 create mode 100644 alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableMapTest.kt
 create mode 100644 alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableSetTest.kt
 create mode 100644 alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableTest.kt
 create mode 100644 alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/AbstractEngine.kt
 create mode 100644 alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/ReactiveEngine.kt
 create mode 100644 alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/AbstractDependencyTest.kt
 create mode 100644 alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/AbstractEngineTest.kt
 create mode 100644 alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineComparison.kt
 create mode 100644 alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineImplementation.kt
 create mode 100644 alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveDependencies.kt
 create mode 100644 alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveEngineImplementation.kt
 create mode 100644 alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/util/DependencyUtils.kt
 create mode 100644 alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NeighborHasConcentration.kt
 create mode 100644 alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestReactiveEngineLoading.kt
 create mode 100755 run_all_tests_reactive.sh

diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index 7bee31df84..8dce9e5fbf 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -5,6 +5,10 @@
       <option name="METHOD_MATCHER_CONFIG" value="java.util.Formatter,format,java.io.Writer,append,com.google.common.base.Preconditions,checkNotNull,org.hibernate.Session,close,java.io.PrintWriter,printf,java.io.PrintStream,printf,java.lang.foreign.Arena,ofAuto,java.lang.foreign.Arena,global,java.util.concurrent.Executors,newFixedThreadPool" />
     </inspection_tool>
     <inspection_tool class="CollectionsFieldAccessReplaceableByMethodCall" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="DataFlowIssue" enabled="false" level="WARNING" enabled_by_default="false">
+      <option name="SUGGEST_NULLABLE_ANNOTATIONS" value="false" />
+      <option name="DONT_REPORT_TRUE_ASSERT_STATEMENTS" value="false" />
+    </inspection_tool>
     <inspection_tool class="LocalCanBeFinal" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="REPORT_VARIABLES" value="false" />
       <option name="REPORT_PARAMETERS" value="true" />
diff --git a/alchemist-api/build.gradle.kts b/alchemist-api/build.gradle.kts
index 74cf14ebd1..ee1c7a35e2 100644
--- a/alchemist-api/build.gradle.kts
+++ b/alchemist-api/build.gradle.kts
@@ -16,6 +16,7 @@ dependencies {
     api(libs.jool)
     api(libs.listset)
     implementation(libs.kotlin.reflect)
+    api(libs.arrow.core)
     testImplementation(libs.kotlin.test)
 }
 
diff --git a/alchemist-api/src/main/java/it/unibo/alchemist/model/Condition.java b/alchemist-api/src/main/java/it/unibo/alchemist/model/Condition.java
index f4d31ef380..84fa0b2599 100644
--- a/alchemist-api/src/main/java/it/unibo/alchemist/model/Condition.java
+++ b/alchemist-api/src/main/java/it/unibo/alchemist/model/Condition.java
@@ -10,6 +10,9 @@
 package it.unibo.alchemist.model;
 
 import it.unibo.alchemist.core.Simulation;
+import it.unibo.alchemist.model.observation.Disposable;
+import it.unibo.alchemist.model.observation.Observable;
+import it.unibo.alchemist.model.observation.ObservableSet;
 import org.danilopianini.util.ListSet;
 
 import java.io.Serializable;
@@ -20,7 +23,7 @@
  * @param <T>
  *     The type which describes the concentration of a molecule
  */
-public interface Condition<T> extends Serializable {
+public interface Condition<T> extends Serializable, Disposable {
 
     /**
      * This method allows cloning this action on a new node. It may result
@@ -46,6 +49,12 @@ public interface Condition<T> extends Serializable {
      */
     ListSet<? extends Dependency> getInboundDependencies();
 
+    /**
+     * @return The set of dependencies which may influence the truth value of this
+     *         condition, as an {@link ObservableSet} of {@link Observable}
+     */
+    ObservableSet<? extends Observable<?>> observeInboundDependencies();
+
     /**
      * @return the node this Condition belongs to
      */
@@ -61,11 +70,24 @@ public interface Condition<T> extends Serializable {
      */
     double getPropensityContribution();
 
+    /**
+     * An observable and reactive view of the corresponding {@link #getPropensityContribution()}.
+     *
+     * @return an observable view of how this condition may influence the propensity.
+     */
+    Observable<Double> observePropensityContribution();
+
     /**
      * @return true if the condition is satisfied in the current environment.
      */
     boolean isValid();
 
+    /**
+     * @return an observable that emits true if the condition is satisfied in the
+     *          current environment.
+     */
+    Observable<Boolean> observeValidity();
+
     /**
      * This method is called by the {@link Simulation} once the {@link Reaction}
      * whose this {@link Condition} belongs to is the next one to be executed, and
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
index df9b70e1e8..861b2855e1 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
@@ -9,6 +9,7 @@
 
 package it.unibo.alchemist.model
 
+import it.unibo.alchemist.model.observation.Observable
 import java.io.Serializable
 import org.danilopianini.util.ListSet
 
@@ -24,6 +25,14 @@ sealed interface Actionable<T> :
      */
     fun canExecute(): Boolean
 
+    /**
+     * Observes whether the reaction can be executed. This observable emits updates
+     * to indicate if the conditions required for execution are satisfied.
+     *
+     * @return An [Observable] emitting true if the reaction van be executed, false otherwise.
+     */
+    fun observeCanExecute(): Observable<Boolean>
+
     /**
      * Executes the reactions.
      */
@@ -88,6 +97,12 @@ sealed interface Actionable<T> :
      */
     val timeDistribution: TimeDistribution<T>
 
+    /**
+     * Emits when this reaction requests the [Scheduler][it.unibo.alchemist.core.Scheduler]
+     * to reschedule this reaction.
+     */
+    val rescheduleRequest: Observable<Unit>
+
     /**
      * Updates the scheduling of this reaction.
      *
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
index 5a781ab16d..b4159d7311 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
@@ -10,6 +10,8 @@
 package it.unibo.alchemist.model
 
 import it.unibo.alchemist.core.Simulation
+import it.unibo.alchemist.model.observation.Observable
+import it.unibo.alchemist.model.observation.ObservableSet
 import java.io.Serializable
 import org.danilopianini.util.ListSet
 
@@ -18,6 +20,7 @@ import org.danilopianini.util.ListSet
  * Every environment must implement this specification.
  * [T] is the [Concentration] type, [P] is the [Position] type.
  */
+@Suppress("TooManyFunctions")
 interface Environment<T, P : Position<out P>> :
     Serializable,
     Iterable<Node<T>> {
@@ -95,6 +98,12 @@ interface Environment<T, P : Position<out P>> :
      */
     fun getNeighborhood(node: Node<T>): Neighborhood<T>
 
+    /**
+     * Given a [node], this method returns an observable view of
+     * its neighborhood.
+     */
+    fun observeNeighborhood(node: Node<T>): Observable<Neighborhood<T>>
+
     /**
      * Allows accessing a [Node] in this [Environment] known its [id].
      * Depending on the implementation, this method may or may not be optimized
@@ -107,11 +116,21 @@ interface Environment<T, P : Position<out P>> :
      */
     val nodes: ListSet<Node<T>>
 
+    /**
+     * An [Observable] view of all the [Node]s that exist in current [Environment].
+     */
+    val observableNodes: ObservableSet<Node<T>>
+
     /**
      * Returns the number of [Node]s currently in the [Environment].
      */
     val nodeCount: Int
 
+    /**
+     * Returns an [Observable] view of the number of [Node]s currently in the [Environment].
+     */
+    val observeNodeCount: Observable<Int>
+
     /**
      * Given a [node] this method returns a list of all the surrounding
      * nodes within the given [range]. Note that this method (depending on the
@@ -122,6 +141,11 @@ interface Environment<T, P : Position<out P>> :
      */
     fun getNodesWithinRange(node: Node<T>, range: Double): ListSet<Node<T>>
 
+    /**
+     * An [Observable] alternative to [getNodesWithinRange].
+     */
+    fun observeNodesWithinRange(node: Node<T>, range: Double): ObservableSet<Node<T>>
+
     /**
      * Given a [position] this method returns a list of all the
      * surrounding nodes within the given [range].
@@ -130,6 +154,11 @@ interface Environment<T, P : Position<out P>> :
      */
     fun getNodesWithinRange(position: P, range: Double): ListSet<Node<T>>
 
+    /**
+     * An [Observable] alternative to [getNodesWithinRange].
+     */
+    fun observeNodesWithinRange(position: P, range: Double): ObservableSet<Node<T>>
+
     /**
      * This method allows to know which are the smallest coordinates represented.
      * Return an array of length [dimensions] containing the smallest
@@ -142,6 +171,11 @@ interface Environment<T, P : Position<out P>> :
      */
     fun getPosition(node: Node<T>): P
 
+    /**
+     * Observe the position of a [node].
+     */
+    fun observePosition(node: Node<T>): Observable<P>
+
     /**
      * Return the current [Simulation], if present, or throws an [IllegalStateException] otherwise.
      */
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
index d8eaff217d..646d2b79c8 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
@@ -8,6 +8,9 @@
  */
 package it.unibo.alchemist.model
 
+import arrow.core.Option
+import it.unibo.alchemist.model.observation.Observable
+import it.unibo.alchemist.model.observation.ObservableMap
 import java.io.Serializable
 import kotlin.reflect.KClass
 import kotlin.reflect.full.isSubclassOf
@@ -60,6 +63,14 @@ interface Node<T> :
      */
     operator fun contains(molecule: Molecule): Boolean
 
+    /**
+     * Observes whether a node contains a [Molecule].
+     *
+     * @param molecule * the molecule to check
+     * @return emit true if the molecule is present, false otherwise
+     */
+    fun observeContains(molecule: Molecule): Observable<Boolean>
+
     /**
      * Calculates the concentration of a molecule.
      *
@@ -69,11 +80,26 @@ interface Node<T> :
      */
     fun getConcentration(molecule: Molecule): T
 
+    /**
+     * Observe the concentration calculated with the given molecule.
+     * The result of this computation is wrapped into an [Option] and
+     * [some][arrow.core.Some] if the value is present, otherwise
+     * [none][arrow.core.None].
+     *
+     * @param molecule the molecule whose concentration will be returned
+     */
+    fun observeConcentration(molecule: Molecule): Observable<Option<T>>
+
     /**
      * @return the molecule corresponding to the i-th position
      */
     val contents: Map<Molecule, T>
 
+    /**
+     * @return an observable view of the molecule corresponding to the i-th position
+     */
+    val observableContents: ObservableMap<Molecule, T>
+
     /**
      * @return an univocal id for this node in the environment
      */
@@ -84,6 +110,11 @@ interface Node<T> :
      */
     val moleculeCount: Int
 
+    /**
+     * Observes the count of different molecules in this node.
+     */
+    val observeMoleculeCount: Observable<Int>
+
     /**
      * @return a list of the node's properties/capabilities
      */
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
new file mode 100644
index 0000000000..9ba47c3b2c
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2010-2025, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import arrow.core.Option
+import arrow.core.none
+import arrow.core.some
+import java.util.Collections
+
+/**
+ * An abstract implementation of the `Observable` interface designed to support observables whose states
+ * are derived from other data sources. Manages the lifecycle of observation and update propagation.
+ *
+ * @param emitOnDistinct whether to emit when the new derived value is different from the current one.
+ * @param T The type of data being observed.
+ */
+abstract class DerivedObservable<T>(private val emitOnDistinct: Boolean = true) : Observable<T> {
+    private val callbacks = LinkedHashMap<Any, List<(T) -> Unit>>()
+
+    private var cached: Option<T> = none()
+
+    private var isListening = false
+
+    override val observingCallbacks: Map<Any, List<(T) -> Unit>>
+        get() = Collections.unmodifiableMap(callbacks)
+
+    override val observers: List<Any>
+        get() = callbacks.keys.toList()
+
+    @Suppress("UNCHECKED_CAST")
+    override val current: T
+        get() {
+            val maybeCached = cached.getOrNull()
+            return if (isListening && maybeCached != null) {
+                maybeCached
+            } else {
+                computeFresh()
+            }
+        }
+
+    override fun onChange(registrant: Any, callback: (T) -> Unit) {
+        val wasEmpty = callbacks.isEmpty()
+        callbacks[registrant] = callbacks[registrant].orEmpty() + callback
+        if (wasEmpty) {
+            val initial = computeFresh()
+            cached = initial.some()
+            callback(initial)
+
+            isListening = true
+            startMonitoring()
+        } else {
+            callback(current)
+        }
+    }
+
+    override fun stopWatching(registrant: Any) {
+        callbacks.remove(registrant)
+
+        if (callbacks.isEmpty() && isListening) {
+            stopMonitoring()
+            isListening = false
+            cached = none()
+        }
+    }
+
+    override fun dispose() {
+        if (isListening) {
+            stopMonitoring()
+        }
+
+        callbacks.clear()
+        isListening = false
+        cached = none()
+    }
+
+    protected abstract fun startMonitoring()
+
+    protected abstract fun stopMonitoring()
+
+    protected abstract fun computeFresh(): T
+
+    protected fun updateAndNotify(newValue: T) {
+        val changed = cached.getOrNull()?.let { it != newValue } ?: true
+        if (!emitOnDistinct || changed) {
+            cached = newValue.some()
+            callbacks.values.forEach { cs ->
+                cs.forEach { it(newValue) }
+            }
+        }
+    }
+}
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Disposable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Disposable.kt
new file mode 100644
index 0000000000..aed501ef9b
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Disposable.kt
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2010-2025, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+/**
+ * Anything taking up some resource and that can be cleared up.
+ */
+fun interface Disposable {
+
+    /**
+     * Disposes and releases the resources held by this object.
+     */
+    fun dispose()
+}
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt
new file mode 100644
index 0000000000..97228cfaaf
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt
@@ -0,0 +1,35 @@
+package it.unibo.alchemist.model.observation
+
+/**
+ * An implementation of [Observable] that emits updates to its observers when triggered manually
+ * via the [emit] method. The observed value is always [Unit]. A standard [MutableObservable] of
+ * [Unit] is not the answer to an observable emitter, because of observable idempotency.
+ *
+ * This class allows multiple observers to register for notifications, and provides the ability
+ * to manually emit updates to those observers.
+ */
+class EventObservable : Observable<Unit> {
+
+    override val observingCallbacks: MutableMap<Any, List<(Unit) -> Unit>> = linkedMapOf()
+
+    override val current: Unit = Unit
+
+    override val observers: List<Any> get() = observingCallbacks.keys.toList()
+
+    /**
+     * Triggers the emission of a notification from this observable notifying
+     * all of its observers.
+     */
+    fun emit() {
+        observingCallbacks.values.forEach { callbacks -> callbacks.forEach { it(Unit) } }
+    }
+
+    override fun onChange(registrant: Any, callback: (Unit) -> Unit) {
+        observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
+        callback(current)
+    }
+
+    override fun stopWatching(registrant: Any) {
+        observingCallbacks.remove(registrant)
+    }
+}
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
new file mode 100644
index 0000000000..58e0540d87
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 2010-2025, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import arrow.core.Option
+
+/**
+ * Represents an observable object that emits updates to registered observers when its value changes.
+ *
+ * @param T The type of the value being observed.
+ */
+interface Observable<T> : Disposable {
+    /**
+     * The current state or value of the observable.
+     */
+    val current: T
+
+    /**
+     * Represents a list of all entities currently observing changes to this observable object.
+     */
+    val observers: List<Any>
+
+    /**
+     * Stores the set of observers along with the list of callbacks associated with them.
+     */
+    val observingCallbacks: Map<Any, List<(T) -> Unit>>
+
+    /**
+     * Registers a callback to be notified of changes in the observable. The callback is invoked
+     * whenever the state of the observable changes.
+     *
+     * @param registrant The entity registering the callback.
+     * @param callback   The callback to be executed when the observable's state changes. It receives
+     *                   the updated value of the observable as an argument.
+     */
+    fun onChange(registrant: Any, callback: (T) -> Unit)
+
+    /**
+     * Unregisters the specified registrant from watching for changes or updates in the observable.
+     *
+     * @param registrant The entity to be unregistered from observing changes.
+     */
+    fun stopWatching(registrant: Any)
+
+    /**
+     * Disposes of the observable by unregistering all currently registered observers.
+     * This method ensures that no further updates or notifications are sent to the observers.
+     */
+    override fun dispose() {
+        observers.forEach { this.stopWatching(it) }
+    }
+
+    /**
+     * Transforms the current observable into a new observable by applying the specified transformation function
+     * to its emitted values.
+     *
+     * @param transform The function to transform each value emitted by this observable.
+     * @return A new observable that emits the transformed values.
+     */
+    fun <S> map(transform: (T) -> S): Observable<S> = object : DerivedObservable<S>() {
+
+        override fun computeFresh(): S = transform(this@Observable.current)
+
+        override fun startMonitoring() {
+            this@Observable.onChange(this) {
+                updateAndNotify(transform(it))
+            }
+        }
+
+        override fun stopMonitoring() {
+            this@Observable.stopWatching(this)
+        }
+
+        override fun toString(): String = "MapObservable($current)[from: ${this@Observable}]"
+    }
+
+    /**
+     * Combines the current observable with another observable, producing a new observable that emits
+     * values derived by applying the provided merge function to the current values of both observables.
+     *
+     * @param other The observable to be merged with the current observable.
+     * @param merge The function that combines the values from the two observables into a single value.
+     * @return A new observable that emits values resulting from merging the two observables.
+     */
+    @Suppress("UNCHECKED_CAST")
+    fun <O, R> mergeWith(other: Observable<O>, merge: (T, O) -> R): Observable<R> = object : DerivedObservable<R>() {
+
+        override fun computeFresh(): R = merge(this@Observable.current, other.current)
+
+        override fun startMonitoring() {
+            val handleUpdate: (Any?) -> Unit = {
+                updateAndNotify(merge(this@Observable.current, other.current))
+            }
+
+            listOf(this@Observable, other).forEach { obs ->
+                obs.onChange(this, handleUpdate)
+            }
+        }
+
+        override fun stopMonitoring() {
+            listOf(this@Observable, other).forEach { it.stopWatching(this) }
+        }
+
+        override fun toString() = "MergeObservable($current)[from: ${this@Observable}, other: $other]"
+    }
+
+    /**
+     * Set of handy extension methods for Observables.
+     */
+    companion object ObservableExtensions {
+
+        /**
+         * Retrieves the current value of the observable if present, or `null` if no value is available.
+         *
+         * @return The current value of the observable, or `null` if it is not set.
+         */
+        fun <T> Observable<Option<T>>.currentOrNull(): T? = current.getOrNull()
+
+        /**
+         * Converts this [Observable] into a [MutableObservable] of the same type [T].
+         * If this observable is already mutable, this observable is returned; however,
+         * if it does not, a new, separate observable will be created, therefore, no
+         * observers are shared between this and the returned observable.
+         *
+         * @return a mutable version of this observable.
+         */
+        fun <T> Observable<T>.asMutable(): MutableObservable<T> =
+            this as? MutableObservable<T> ?: object : MutableObservable<T> {
+                override var current: T = this@asMutable.current
+                    get() = this@asMutable.current
+
+                override var observers: List<Any> = emptyList()
+
+                override val observingCallbacks: MutableMap<Any, List<(T) -> Unit>> = mutableMapOf()
+
+                override fun onChange(registrant: Any, callback: (T) -> Unit) {
+                    observers += registrant
+                    observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
+                    this@asMutable.onChange(this to registrant, callback)
+                }
+
+                override fun stopWatching(registrant: Any) {
+                    observers -= registrant
+                    observingCallbacks.remove(registrant)
+                    this@asMutable.stopWatching(this to registrant)
+                }
+            }
+    }
+}
+
+/**
+ * A MutableObservable represents an extension of the Observable interface, designed to maintain
+ * mutable state and notify its observers when the state changes. Updates are mainly
+ * performed thanks to the [update] function.
+ *
+ * @param T The type of the value being observed and modified.
+ */
+interface MutableObservable<T> : Observable<T> {
+    override var current: T
+
+    /**
+     * Updates the current value using the specified transformation function and returns the previous value.
+     *
+     * @param computeNewValue A function that computes the new value based on the current value.
+     * @return The previous value before the update.
+     */
+    fun update(computeNewValue: (T) -> T): T = current.also {
+        current = computeNewValue(current)
+    }
+
+    /**
+     * Factory methods container.
+     */
+    companion object {
+
+        /**
+         * Creates and returns a new instance of a [MutableObservable] initialized with the given value.
+         * The resulting observable allows its state to be modified and notifies registered observers of any changes.
+         *
+         * @param T The type of the value being observed.
+         * @param initial The initial value of the observable.
+         * @return A new instance of [MutableObservable] initialized with the provided value.
+         */
+        fun <T> observe(initial: T): MutableObservable<T> = object : MutableObservable<T> {
+            override val observingCallbacks: MutableMap<Any, List<(T) -> Unit>> = linkedMapOf()
+
+            override var current: T = initial
+                set(value) {
+                    if (value != field) {
+                        field = value
+                        observingCallbacks.values.forEach { callbacks -> callbacks.forEach { it(value) } }
+                    }
+                }
+
+            override val observers: List<Any> get() = observingCallbacks.keys.toList()
+
+            override fun onChange(registrant: Any, callback: (T) -> Unit) {
+                callback(current)
+                observingCallbacks[registrant] = observingCallbacks[registrant]?.let {
+                    it + callback
+                } ?: listOf(callback)
+            }
+
+            override fun stopWatching(registrant: Any) {
+                observingCallbacks.remove(registrant)
+            }
+        }
+
+        /**
+         * Handy method to update the optional[Option] contents of this [MutableObservable].
+         * Applies the given function to the value contained by the underlying [Option],
+         * if it is empty nothing is computed.
+         *
+         * @param updateFunc the update function to perform on the value wrapped by the underlying [Option]
+         */
+        fun <T> MutableObservable<Option<T>>.updateValue(updateFunc: (T) -> T) {
+            update { it.map(updateFunc) }
+        }
+    }
+}
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt
new file mode 100644
index 0000000000..e9877ba96f
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt
@@ -0,0 +1,343 @@
+/*
+ * Copyright (C) 2010-2025, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import arrow.core.Option
+import arrow.core.none
+import arrow.core.some
+import it.unibo.alchemist.model.observation.ObservableMutableSet.Companion.toObservableSet
+import kotlin.collections.forEach
+
+/**
+ * Set of useful extensions on [Observable] and collections of observables.
+ */
+object ObservableExtensions {
+
+    /**
+     * Set of useful extensions on [ObservableList].
+     */
+    object ObservableListExtensions {
+
+        /**
+         * Combines the content of an `ObservableList` into a single observable by applying a mapping function
+         * to each element and aggregating the results.
+         *
+         * @param map A function that maps each element of the `ObservableList` to an `Observable`.
+         * @param aggregator A function that aggregates the mapped results into a single value.
+         * @return An `Observable` emitting the aggregated result of the mapped content from the `ObservableList`.
+         */
+        fun <T, R, O> ObservableList<T>.combineLatest(
+            map: (T) -> Observable<R>,
+            aggregator: (List<R>) -> O,
+        ): Observable<O> = combineLatestCollection(map, aggregator)
+
+        /**
+         * Transforms an [ObservableList] of type [T] into a single [Observable] of type [Option]<[O]> by fusing the
+         * individual observables obtained from each item in the list.
+         *
+         * @param T The type of elements in the [ObservableList].
+         * @param O The type of the resulting fused observable.
+         * @param map A function that maps each element of the source [ObservableList] to an [Observable] of type [O].
+         * @return An [Observable] of type [Option]<[O]> that is safe to use on empty lists.
+         */
+        fun <T, O> ObservableList<T>.flatMap(map: (T) -> Observable<O>): Observable<Option<O>> = flatMapCollection(map)
+
+        /**
+         * Converts this [ObservableList] of [observables][Observable] into a unique observable.
+         *
+         * @return a unique observable wrapping in one place all the notifications emitted by this [ObservableList]
+         */
+        @Suppress("UNCHECKED_CAST")
+        fun ObservableList<out Observable<*>>.merge(): Observable<Option<Any?>> = flatMap { it as Observable<Any?> }
+
+        /**
+         * Converts the given [ObservableList] of [observables][Observable] into a unique observable.
+         *
+         * @return a unique observable wrapping in one place all the notifications emitted by this [ObservableList]
+         */
+        @JvmStatic
+        @JvmName("mergeObservables")
+        @Suppress("UNCHECKED_CAST")
+        fun merge(observables: ObservableList<out Observable<*>>): Observable<Option<Any?>> =
+            observables.flatMap { it as Observable<Any?> }
+    }
+
+    /**
+     * Set of useful extensions on [ObservableSet].
+     */
+    object ObservableSetExtensions {
+
+        /**
+         * Combines the content of an `ObservableSet` into a single observable by applying a mapping function
+         * to each element and aggregating the results.
+         * This function generates a single observable that emits every time the underlying set of contents is changed,
+         * or some of the values (which are in turn observables) emit a changes, triggering the re-evaluation
+         * of the [aggregation][aggregator] function.
+         *
+         * @param map A function that maps each element of the `ObservableSet` to an `Observable`.
+         * @param aggregator A function that aggregates the mapped results into a single value.
+         * @return An `Observable` emitting the aggregated result of the mapped content from the `ObservableSet`.
+         */
+        fun <T, R, O> ObservableSet<T>.combineLatest(
+            map: (T) -> Observable<R>,
+            aggregator: (Iterable<R>) -> O,
+        ): Observable<O> = combineLatestCollection(map, aggregator)
+
+        /**
+         * Transforms an [ObservableSet] of type [T] into a single [Observable] of type [Option]<[O]> by fusing the
+         * individual observables obtained from each item in the set.
+         *
+         * The resulting observable is **total**:
+         * - If the set is empty, it emits (and its [Observable.current] is) [arrow.core.None]
+         * - If the set is non-empty, it emits [arrow.core.Some] values coming from any mapped observable
+         *
+         * @param T The type of elements in the [ObservableSet].
+         * @param O The type of the resulting fused observable.
+         * @param map A function that maps each element of the source [ObservableSet] to an [Observable] of type [O].
+         * @return An [Observable] of type [Option]<[O]> that is safe to use on empty sets.
+         */
+        fun <T, O> ObservableSet<T>.flatMap(map: (T) -> Observable<O>): Observable<Option<O>> = flatMapCollection(map)
+
+        /**
+         * Converts this [ObservableSet] of [observables][Observable] into a unique observable that emits
+         * when either this set would have changed (addition/removal of members) or one of its members
+         * emits a value.
+         *
+         * The resulting observable is safe on empty sets: it emits [arrow.core.None] when the set is empty.
+         *
+         * @return a unique observable wrapping in one place all the notifications emitted by this [ObservableSet]
+         */
+        @Suppress("UNCHECKED_CAST")
+        fun ObservableSet<out Observable<*>>.merge(): Observable<Option<Any?>> = flatMap { it as Observable<Any?> }
+
+        /**
+         * Converts the given [ObservableSet] of [observables][Observable] into a unique observable that emits
+         * when either this set would have changed (addition/removal of members) or one of its members
+         * emits a value.
+         *
+         * The resulting observable is safe on empty sets: it emits [arrow.core.None] when the set is empty.
+         *
+         * @return a unique observable wrapping in one place all the notifications emitted by this [ObservableSet]
+         */
+        @JvmStatic
+        @JvmName("mergeObservables")
+        @Suppress("UNCHECKED_CAST")
+        fun merge(observables: ObservableSet<out Observable<*>>): Observable<Option<Any?>> =
+            observables.flatMap { it as Observable<Any?> }
+
+        /**
+         * Returns a new [ObservableSet] applying the given [predicate] to each element.
+         * The resulting collection is this collection with all the items that satisfy the given [predicate].
+         * This function is backed by the standard `filter` of [sets][Set].
+         *
+         * @param predicate the predicate to apply for each element of this collection.
+         * @return a new [ObservableSet] with the items that satisfy the input [predicate].
+         */
+        fun <T> ObservableSet<T>.filter(predicate: (T) -> Boolean): ObservableSet<T> =
+            this.toSet().filter(predicate).toObservableSet()
+
+        /**
+         * Combines this observable set with another, producing a new observable set that represents
+         * the union of both sets.
+         *
+         * @param other The observable set to be merged with the current one.
+         * @return A new observable set that emits the union of the values.
+         */
+        infix fun <T> ObservableSet<T>.union(other: ObservableSet<T>): ObservableSet<T> = object : ObservableSet<T> {
+            private val backing = this@union.mergeWith(other) { s1, s2 -> s1 + s2 }
+
+            override val current: Set<T> get() = backing.current
+
+            override var observers: List<Any> = emptyList()
+
+            override val observingCallbacks: MutableMap<Any, List<(Set<T>) -> Unit>> = mutableMapOf()
+
+            override val observableSize: Observable<Int> = backing.map { it.size }
+
+            override fun onChange(registrant: Any, callback: (Set<T>) -> Unit) {
+                observers += registrant
+                observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
+                backing.onChange(this to registrant, callback)
+            }
+
+            override fun stopWatching(registrant: Any) {
+                observers -= registrant
+                observingCallbacks.remove(registrant)
+                backing.stopWatching(registrant)
+            }
+
+            override fun observeMembership(item: T): Observable<Boolean> =
+                this@union.observeMembership(item).mergeWith(other.observeMembership(item)) { a, b -> a || b }
+
+            override fun toSet(): Set<T> = current
+
+            override fun toList(): List<T> = current.toList()
+
+            override fun copy(): ObservableSet<T> = ObservableMutableSet<T>().apply {
+                current.forEach(this::add)
+            }
+
+            override fun contains(item: T): Boolean = item in current
+
+            override fun toString(): String = "UnionObservableSet($current)[from: ${this@union}, other: $other]"
+        }
+    }
+
+    private fun <T, C : Collection<T>, R, O> Observable<C>.combineLatestCollection(
+        map: (T) -> Observable<R>,
+        aggregator: (List<R>) -> O,
+    ): Observable<O> = object : DerivedObservable<O>() {
+
+        private val sources = mutableMapOf<T, Observable<R>>()
+
+        override fun computeFresh(): O = aggregator(this@combineLatestCollection.current.map { map(it).current })
+
+        @Suppress("UNCHECKED_CAST")
+        override fun startMonitoring() {
+            val callback: (C) -> Unit = { current ->
+                reconcile(
+                    sources = sources,
+                    current = current,
+                    map = map,
+                    doOnChange = { updateAndNotify(computeFresh()) },
+                    postCleanup = { updateAndNotify(computeFresh()) },
+                )
+            }
+
+            this@combineLatestCollection.onChange(this, callback)
+            callback(ArrayList(this@combineLatestCollection.current) as C)
+        }
+
+        override fun stopMonitoring() {
+            this@combineLatestCollection.stopWatching(this)
+            sources.values.forEach { it.stopWatching(this@combineLatestCollection) }
+            sources.clear()
+        }
+    }
+
+    private fun <T, C : Collection<T>, O> Observable<C>.flatMapCollection(
+        map: (T) -> Observable<O>,
+    ): Observable<Option<O>> = object : DerivedObservable<Option<O>>() {
+        private val sources = mutableMapOf<T, Observable<O>>()
+
+        override fun computeFresh(): Option<O> = this@flatMapCollection.current.firstOrNull()
+            ?.let { key -> sources[key]?.current ?: map(key).current }
+            ?.some()
+            ?: none()
+
+        @Suppress("UNCHECKED_CAST")
+        override fun startMonitoring() {
+            val callback: (C) -> Unit = { current ->
+                reconcile(
+                    sources = sources,
+                    current = current,
+                    map = map,
+                    doOnChange = { updateAndNotify(it.some()) },
+                    postCleanup = {
+                        if (this@flatMapCollection.current.isEmpty()) {
+                            updateAndNotify(none())
+                        }
+                    },
+                )
+            }
+
+            this@flatMapCollection.onChange(this, callback)
+            callback(ArrayList(this@flatMapCollection.current) as C)
+        }
+
+        override fun stopMonitoring() {
+            this@flatMapCollection.stopWatching(this)
+            sources.values.forEach { it.stopWatching(this@flatMapCollection) }
+            sources.clear()
+        }
+    }
+
+    private fun <T, O> Observable<out Collection<T>>.reconcile(
+        sources: MutableMap<T, Observable<O>>,
+        current: Collection<T>,
+        map: (T) -> Observable<O>,
+        doOnChange: (O) -> Unit,
+        postCleanup: () -> Unit,
+    ) {
+        val currentSet = current.toSet()
+        (sources.keys - currentSet).forEach { sources.remove(it)?.stopWatching(this) }
+        (currentSet - sources.keys).forEach { key ->
+            with(map(key)) {
+                sources[key] = this
+                onChange(this@reconcile, doOnChange)
+            }
+        }
+        postCleanup()
+    }
+
+    /**
+     * Collects the latest values emitted by a list of [Observable]s and transforms them
+     * into a new [Observable] using the provided collector function.
+     *
+     * @param T the type of the values emitted by the source [Observable]s.
+     * @param O the type of the combined and transformed result emitted by the resulting [Observable].
+     * @param collector a function that takes a list of the latest values from the source [Observable]s
+     *                  and transforms them into a result of type [O], which will be emitted by the resulting
+     *                  [Observable].
+     * @return a [Observable] of type [O], which emits the transformed result whenever the
+     *         state of the source [Observable]s changes.
+     */
+    fun <T, O> List<Observable<T>>.combineLatest(collector: (List<T>) -> O): Observable<Option<O>> =
+        object : DerivedObservable<Option<O>>() {
+
+            override fun computeFresh(): Option<O> = this@combineLatest.takeIf { it.isNotEmpty() }
+                ?.let { _ -> collector(this@combineLatest.map { it.current }).some() }
+                ?: arrow.core.none()
+
+            override fun startMonitoring() {
+                this@combineLatest.forEach { observable ->
+                    observable.onChange(this) { updateAndNotify(computeFresh()) }
+                }
+            }
+
+            override fun stopMonitoring() {
+                this@combineLatest.forEach { it.stopWatching(this) }
+            }
+        }
+
+    /**
+     * Transforms the items emitted by this [Observable] into observables, then flatten the emissions from those
+     * into a single observable mirroring the most recently emitted observable.
+     *
+     * @param transform a function that returns an [Observable] for reach item emitted by the source.
+     * @return an [Observable] that emist the items emitted by the observable returned by [transform].
+     */
+    fun <T, R> Observable<T>.switchMap(transform: (T) -> Observable<R>): Observable<R> =
+        object : DerivedObservable<R>() {
+            private var innerSubscription: Observable<R>? = null
+
+            override fun computeFresh(): R = transform(this@switchMap.current).current
+
+            override fun startMonitoring() {
+                this@switchMap.onChange(this, ::switchInner)
+                switchInner(this@switchMap.current)
+            }
+
+            override fun stopMonitoring() {
+                this@switchMap.stopWatching(this)
+                innerSubscription?.stopWatching(this)
+                innerSubscription = null
+            }
+
+            private fun switchInner(value: T) {
+                innerSubscription?.stopWatching(this)
+                with(transform(value)) {
+                    innerSubscription = this
+                    onChange(this@switchMap, ::updateAndNotify)
+                    updateAndNotify(this.current)
+                }
+            }
+        }
+}
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt
new file mode 100644
index 0000000000..1b46a7dbc6
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2010-2025, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import java.util.Collections
+
+/**
+ * Represents a list that allows observation of its contents and provides notifications on changes.
+ * This interface supports observing the entire list and various utility operations.
+ */
+interface ObservableList<T> : Observable<List<T>> {
+
+    /**
+     * An observable that emits the current size of the list.
+     */
+    val observableSize: Observable<Int>
+
+    /**
+     * Observes changes to the list and triggers the provided callback function whenever the list changes.
+     * The callback will be invoked with the current list of items as a parameter.
+     *
+     * @param registrant The object registering for change notifications. Used to manage the lifecycle of the observer.
+     * @param callback The function to be invoked whenever the list changes. It receives the current list of items as
+     *                 a parameter.
+     */
+    override fun onChange(registrant: Any, callback: (List<T>) -> Unit)
+
+    /**
+     * Returns the element at the specified index in the list.
+     */
+    operator fun get(index: Int): T
+
+    /**
+     * Returns an unmodifiable view of the current list of items in the observable list.
+     *
+     * @return A [List] containing all the items currently in the observable list.
+     */
+    fun toList(): List<T>
+
+    /**
+     * Creates and returns a copy of the current ObservableList.
+     *
+     * @return A new ObservableList containing the same elements as the current list.
+     */
+    fun copy(): ObservableList<T>
+
+    /**
+     * Checks if the specified item is present in the observable list.
+     *
+     * @param item The item to be checked for presence in the list.
+     * @return `true` if the item exists in the list, `false` otherwise.
+     */
+    operator fun contains(item: T): Boolean
+
+    /**
+     * A companion object for the [ObservableList] class, providing a simple factory.
+     */
+    companion object {
+
+        /**
+         * Creates a new [ObservableList] and populates it with the specified items.
+         *
+         * @param items The items to be added to the newly created `ObservableMutableList`.
+         * The items are provided as a variable number of arguments.
+         * @return A new [ObservableList] containing the specified items.
+         */
+        operator fun <T> invoke(vararg items: T): ObservableList<T> = ObservableMutableList(*items)
+    }
+}
+
+/**
+ * A mutable observable list implementation, which allows for observing changes to the list and
+ * provides notifications when its contents are modified. This class supports addition, removal,
+ * updates, and observation of modifications to the list.
+ *
+ * @param T The type of elements maintained by this list.
+ */
+class ObservableMutableList<T> : ObservableList<T> {
+
+    private val backing: MutableList<T> = ArrayList()
+    private val sizeObservable = MutableObservable.observe(0)
+
+    override val observableSize: Observable<Int> = sizeObservable
+
+    override val current: List<T> get() = Collections.unmodifiableList(backing)
+
+    override val observers: List<Any> get() = observingCallbacks.keys.toList()
+
+    override val observingCallbacks: MutableMap<Any, List<(List<T>) -> Unit>> = linkedMapOf()
+
+    /**
+     * Adds an item to the observable list.
+     * Observers of the list will be notified of the change.
+     *
+     * @param item The item to be added to the list.
+     * @return `true` (as specified by [MutableList.add])
+     */
+    fun add(item: T): Boolean {
+        val result = backing.add(item)
+        notifyObservers()
+        return result
+    }
+
+    /**
+     * Adds an item at the specified index.
+     * Observers of the list will be notified of the change.
+     *
+     * @param index The index at which the specified element is to be inserted
+     * @param item The item to be added to the list.
+     */
+    fun add(index: Int, item: T) {
+        backing.add(index, item)
+        notifyObservers()
+    }
+
+    /**
+     * Appends all of the elements in the specified collection to the end of this list.
+     *
+     * @param items collection containing elements to be added to this list.
+     * @return `true` if this list changed as a result of the call
+     */
+    fun addAll(items: Collection<T>): Boolean = if (items.isNotEmpty()) {
+        val result = backing.addAll(items)
+        notifyObservers()
+        result
+    } else {
+        false
+    }
+
+    /**
+     * Removes the first occurrence of the specified item from the observable list, if it is present.
+     * If the list changes, observers will be notified.
+     *
+     * @param item The item to be removed from the list.
+     * @return `true` if the list contained the specified element
+     */
+    fun remove(item: T): Boolean {
+        val result = backing.remove(item)
+        if (result) {
+            notifyObservers()
+        }
+        return result
+    }
+
+    /**
+     * Removes the element at the specified position in this list.
+     *
+     * @param index the index of the element to be removed
+     * @return the element that was removed from the list
+     */
+    fun removeAt(index: Int): T {
+        val result = backing.removeAt(index)
+        notifyObservers()
+        return result
+    }
+
+    /**
+     * Replaces the element at the specified position in this list with the specified element.
+     *
+     * @param index index of the element to replace
+     * @param element element to be stored at the specified position
+     * @return the element previously at the specified position
+     */
+    operator fun set(index: Int, element: T): T {
+        val old = backing.set(index, element)
+        if (old != element) {
+            notifyObservers()
+        }
+        return old
+    }
+
+    /**
+     * Removes all of the elements from this list.
+     */
+    fun clear() {
+        if (backing.isNotEmpty()) {
+            backing.clear()
+            notifyObservers()
+        }
+    }
+
+    override fun onChange(registrant: Any, callback: (List<T>) -> Unit) {
+        observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
+        callback(toList())
+    }
+
+    override fun stopWatching(registrant: Any) {
+        observingCallbacks.remove(registrant)
+    }
+
+    override fun dispose() {
+        observingCallbacks.clear()
+        sizeObservable.dispose()
+        backing.clear()
+    }
+
+    override operator fun get(index: Int): T = backing[index]
+
+    override fun toList(): List<T> = Collections.unmodifiableList(ArrayList(backing))
+
+    override fun copy(): ObservableMutableList<T> = ObservableMutableList<T>().apply {
+        this@ObservableMutableList.backing.forEach(this::add)
+    }
+
+    override operator fun contains(item: T): Boolean = backing.contains(item)
+
+    /**
+     * Adds an item to the observable list.
+     * Observers of the list will be notified of the change.
+     *
+     * @param item The item to be added to the list.
+     */
+    operator fun plusAssign(item: T) {
+        add(item)
+    }
+
+    /**
+     * Removes the specified item from the observable list.
+     *
+     * @param item The item to be removed from the list.
+     */
+    operator fun minusAssign(item: T) {
+        remove(item)
+    }
+
+    private fun notifyObservers() {
+        sizeObservable.update { backing.size }
+        val snapshot = toList()
+        observingCallbacks.values.forEach { callbacks ->
+            callbacks.forEach { it(snapshot) }
+        }
+    }
+
+    /**
+     * A companion object for the `ObservableMutableList` class, providing handy factories.
+     */
+    companion object {
+
+        /**
+         * Converts the current list into an observable mutable list.
+         * @see ObservableMutableList
+         *
+         * @return An instance of `ObservableMutableList` containing all elements from the original list.
+         */
+        fun <T> List<T>.toObservableList(): ObservableMutableList<T> = ObservableMutableList<T>().also {
+            it.addAll(this)
+        }
+
+        /**
+         * Creates a new [ObservableMutableList] and populates it with the specified items.
+         *
+         * @param items The items to be added to the newly created `ObservableMutableList`.
+         * The items are provided as a variable number of arguments.
+         * @return A new [ObservableMutableList] containing the specified items.
+         */
+        operator fun <T> invoke(vararg items: T): ObservableMutableList<T> = ObservableMutableList<T>().apply {
+            items.forEach(this::add)
+        }
+    }
+}
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
new file mode 100644
index 0000000000..570882a6cc
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
@@ -0,0 +1,252 @@
+/*
+ * Copyright (C) 2010-2025, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import arrow.core.Option
+import arrow.core.none
+import arrow.core.some
+import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
+import java.util.Collections
+
+/**
+ * Represents an observable map that allows observation of changes to its contents,
+ * as well as observation of keys (i.e. addition, removal and content changes)
+ *
+ * @param K The type of keys maintained by the map.
+ * @param V The type of mapped values.
+ */
+interface ObservableMap<K, V> : Observable<Map<K, V>> {
+
+    /**
+     * Retrieves the observable representation of the value associated with the specified key
+     * in the observable map. The resulting observable emits updates whenever the value for
+     * the given key changes, is added, or is removed.
+     *
+     * @param key The key whose associated value is to be retrieved.
+     * @return An observable emitting an optional value. If the key is present and associated
+     *         with a value, the value is wrapped in `Option.Some`. If the key is absent, it
+     *         emits `Option.None`.
+     */
+    operator fun get(key: K): Observable<Option<V>>
+
+    /**
+     * Checks whether the specified key is present in the observable map.
+     *
+     * @param key The key to be checked for presence in the map.
+     * @return true if the key is present in the map, false otherwise.
+     */
+    operator fun contains(key: K): Boolean
+
+    /**
+     * Tests whether this map is empty.
+     *
+     * @return true if this observable map is empty, false otherwise.
+     */
+    fun isEmpty(): Boolean
+
+    /**
+     * Converts the observable map into a standard, non-observable map.
+     * The returned map reflects the contents of the observable map at the time of invocation,
+     * and it's unmodifiable.
+     *
+     * @return An unmodifiable map containing the key-value pairs of the observable map.
+     */
+    fun asMap(): Map<K, V>
+
+    /**
+     * Simple extensions for the observable map.
+     */
+    companion object {
+
+        /**
+         * Retrieves the value associated with the specified key in the observable map,
+         * or returns a default value using the provided function if the key is not present
+         * or the value is not [none][arrow.core.None].
+         *
+         * @param key The key whose associated value is to be retrieved.
+         * @param defaultProvider A function that provides a default value if the key
+         *        is not present in the observable map.
+         * @return The value associated with the specified key, or the value provided
+         *         by the default function if the key is absent.
+         */
+        fun <K, V> ObservableMap<in K, out V>.getOrElse(key: K, defaultProvider: () -> V): V =
+            this.takeIf { key in this }?.get(key)?.current?.getOrNull() ?: defaultProvider()
+    }
+}
+
+/**
+ * A class that represents an observable, mutable map. Allows observation of map changes,
+ * including addition, removal, modifications of key-value pairs, and observation of
+ * particular keys for their value changes.
+ *
+ * @param K The type of keys maintained by the map.
+ * @param V The type of mapped values.
+ * @property backingMap The internal mutable map that stores the key-value pairs.
+ */
+open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> = linkedMapOf()) : ObservableMap<K, V> {
+
+    private val keyObservables: MutableMap<K, MutableObservable<Option<V>>> = linkedMapOf()
+    override val observingCallbacks: MutableMap<Any, List<(Map<K, V>) -> Unit>> = linkedMapOf()
+
+    override val current: Map<K, V> = Collections.unmodifiableMap(backingMap)
+
+    override val observers: List<Any> get() = observingCallbacks.keys.toList()
+
+    init {
+        if (backingMap.isNotEmpty()) {
+            backingMap.forEach { (key, value) ->
+                keyObservables[key] = observe(value.some())
+            }
+        }
+    }
+
+    /**
+     * Adds the specified key-value pair to the map. If the key already exists, the value is updated.
+     * Observers are notified if the value changes.
+     *
+     * @param key The key to be added or updated in the map.
+     * @param value The value associated with the specified key.
+     */
+    fun put(key: K, value: V) {
+        val previous: V? = backingMap.put(key, value)
+        if (previous != value) {
+            getAsMutable(key).update { value.some() }
+            notifyMapObservers()
+        }
+    }
+
+    /**
+     * Removes the mapping for the specified key from the map, if it exists.
+     * Notifies observers if the key had an associated value before removal.
+     *
+     * @param key The key whose mapping is to be removed from the map.
+     * @return the previous value associated with the key, or null if the key was not present in the map.
+     */
+    fun remove(key: K): V? = backingMap.remove(key).also {
+        val previousObservedValue = keyObservables[key]?.update { none() } ?: none()
+        if (previousObservedValue.isSome()) notifyMapObservers()
+    }
+
+    /**
+     * Replaces the whole content of this map with [from], like doing a `clear` followed
+     * by a `putAll`, * but without notifying per-key observers for keys that remain
+     * present (unless their value changes).
+     *
+     * @param from A map containing the new key-value pairs to populate the map with.
+     */
+    fun clearAndPutAll(from: Map<K, V>) {
+        var changed = false
+        val keysToRemove = backingMap.keys.toSet() - from.keys
+        if (keysToRemove.isNotEmpty()) {
+            keysToRemove.forEach { key ->
+                backingMap.remove(key)
+                keyObservables[key]?.update { none() }
+            }
+            changed = true
+        }
+
+        if (from.isNotEmpty()) {
+            from.forEach { (key, value) ->
+                val previous = backingMap.put(key, value)
+                if (previous != value) {
+                    getAsMutable(key).update { value.some() }
+                    changed = true
+                }
+            }
+        }
+
+        if (changed) {
+            notifyMapObservers()
+        }
+    }
+
+    override fun onChange(registrant: Any, callback: (Map<K, V>) -> Unit) {
+        observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
+        callback(current.toMap())
+    }
+
+    override fun stopWatching(registrant: Any) {
+        observingCallbacks.remove(registrant)
+        with(keyObservables.iterator()) {
+            while (hasNext()) {
+                val (_, obs) = next()
+                obs.stopWatching(registrant)
+                if (obs.observers.isEmpty()) {
+                    remove()
+                }
+            }
+        }
+    }
+
+    override fun dispose() {
+        keyObservables.values.forEach { it.dispose() }
+        keyObservables.clear()
+        observingCallbacks.keys.forEach(::stopWatching)
+        observingCallbacks.clear()
+        backingMap.clear()
+    }
+
+    override fun isEmpty(): Boolean = backingMap.isEmpty()
+
+    /**
+     * Creates and returns a copy of the current ObservableMutableMap.
+     *
+     * @return A new instance of ObservableMutableMap containing the same key-value pairs as the original.
+     */
+    fun copy(): ObservableMutableMap<K, V> = ObservableMutableMap(backingMap.toMutableMap())
+
+    override fun asMap(): Map<K, V> = Collections.unmodifiableMap(backingMap)
+
+    override operator fun get(key: K): Observable<Option<V>> = getAsMutable(key)
+
+    override fun contains(key: K): Boolean = backingMap.containsKey(key)
+
+    /**
+     * @see [put]
+     */
+    operator fun set(key: K, value: V) = put(key, value)
+
+    /**
+     * @see [put]
+     */
+    operator fun plus(entry: Pair<K, V>) = put(entry.first, entry.second)
+
+    /**
+     * @see [remove]
+     */
+    operator fun minus(key: K) = remove(key)
+
+    private fun notifyMapObservers() = observingCallbacks.values.forEach { callbacks ->
+        callbacks.forEach { it(current.toMap()) }
+    }
+
+    private fun getAsMutable(key: K): MutableObservable<Option<V>> = keyObservables.getOrPut(key) { observe(none()) }
+
+    /**
+     * Simple utility function for the ObservableMaps.
+     */
+    companion object ObservableMapExtensions {
+
+        /**
+         * Inserts or updates a key-value pair in the ObservableMutableMap. If the key already exists,
+         * its value is updated using the provided transformation function. If the key does not exist,
+         * a new key-value pair is added with the value derived from the transformation function.
+         *
+         * @param key The key to be added or updated in the map.
+         * @param valueUpdate A function that computes the new value based on the current value
+         * (or `null` if the key does not exist).
+         */
+        fun <K, V> ObservableMutableMap<K, V>.upsertValue(key: K, valueUpdate: (V?) -> V) {
+            getAsMutable(key).update {
+                valueUpdate(it.getOrNull()).apply { put(key, this) }.some()
+            }
+        }
+    }
+}
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt
new file mode 100644
index 0000000000..37b6032318
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt
@@ -0,0 +1,232 @@
+/*
+ * Copyright (C) 2010-2025, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import arrow.core.getOrElse
+import java.util.Collections
+
+/**
+ * Represents a set that allows observation of its contents and provides notifications on changes.
+ * This interface supports observing the entire set, individual item membership, and various utility operations.
+ */
+interface ObservableSet<T> : Observable<Set<T>> {
+
+    /**
+     * An observable that emits the current size of the set.
+     */
+    val observableSize: Observable<Int>
+
+    /**
+     * Observes changes to the set and triggers the provided callback function whenever the set changes.
+     * The callback will be invoked with the current set of items as a parameter.
+     *
+     * @param registrant The object registering for change notifications. Used to manage the lifecycle of the observer.
+     * @param callback The function to be invoked whenever the set changes. It receives the current set of items as
+     *                 a parameter.
+     */
+    override fun onChange(registrant: Any, callback: (Set<T>) -> Unit)
+
+    /**
+     * Observes the membership status of a specific item in the set.
+     * The returned observable will emit `true` if the item is a member of the set,
+     * and `false` otherwise. Emits updates whenever the membership status changes.
+     *
+     * @param item The item whose membership status is to be observed.
+     * @return An observable emitting `true` if the item is in the set, `false` otherwise.
+     */
+    fun observeMembership(item: T): Observable<Boolean>
+
+    /**
+     * Returns an unmodifiable view of the current set of items in the observable set.
+     *
+     * @return A `Set` containing all the items currently in the observable set.
+     */
+    fun toSet(): Set<T>
+
+    /**
+     * Returns an unmodifiable view of the current list of items in the observable set.
+     *
+     * @return A [List] containing all the items currently in the observable set.
+     */
+    fun toList(): List<T>
+
+    /**
+     * Creates and returns a copy of the current ObservableSet.
+     *
+     * @return A new ObservableSet containing the same elements as the current set.
+     */
+    fun copy(): ObservableSet<T>
+
+    /**
+     * Checks if the specified item is present in the observable set.
+     *
+     * @param item The item to be checked for presence in the set.
+     * @return `true` if the item exists in the set, `false` otherwise.
+     */
+    operator fun contains(item: T): Boolean
+
+    /**
+     * A companion object for the [ObservableSet] class, providing a simple factory.
+     */
+    companion object {
+
+        /**
+         * Creates a new [ObservableSet] and populates it with the specified items.
+         *
+         * @param items The items to be added to the newly created `ObservableMutableSet`.
+         * The items are provided as a variable number of arguments.
+         * @return A new [ObservableSet] containing the specified items.
+         */
+        operator fun <T> invoke(vararg items: T): ObservableSet<T> = ObservableMutableSet(*items)
+    }
+}
+
+/**
+ * A mutable observable set implementation, which allows for observing changes to the set and
+ * provides notifications when its contents are modified. This class supports addition, removal,
+ * and observation of modifications to the set.
+ *
+ * @param T The type of elements maintained by this set.
+ */
+class ObservableMutableSet<T> : ObservableSet<T> {
+
+    private val backing = ObservableMutableMap<T, Boolean>()
+
+    override val observableSize: Observable<Int> = backing.map { it.keys.size }
+
+    override val current: Set<T> get() = backing.current.keys
+
+    override val observers: List<Any> get() = backing.observers.map { this to it }
+
+    override val observingCallbacks: MutableMap<Any, List<(Set<T>) -> Unit>> = mutableMapOf()
+
+    /**
+     * Adds an item to the observable set.
+     * If the item does not already exist in the set, it will be added, and observers
+     * of the set will be notified of the change.
+     *
+     * @param item The item to be added to the set.
+     */
+    fun add(item: T) {
+        if (item !in backing.current) backing.put(item, true)
+    }
+
+    /**
+     * Removes the specified item from the observable set.
+     * If the item exists in the set, it will be removed, and observers of the set
+     * will be notified of the change.
+     *
+     * @param item The item to be removed from the set.
+     * @return true if the set contained the specified [item]
+     */
+    fun remove(item: T): Boolean = backing.remove(item) != null
+
+    /**
+     * Clears the current set and inserts the given [items]. This is the equivalent
+     * of calling [remove] for each `this - [items]` element, and [add] for each
+     * `[items] - this` notifying every subscriber.
+     *
+     * > WARNING: calling so many times add and remove for basically every new element
+     * added in this collection will trigger `|N ∪ M|` times the callbacks associated with
+     * this set resulting in a non-negligible time spent updating observers. Please be
+     * careful when using this method.
+     *
+     * @param items
+     */
+    fun clearAndAddAll(items: Set<T>) {
+        val (toRemove, toAdd) = with(this.toSet()) { (this - items) to (items - this) }
+        toRemove.forEach(::remove)
+        toAdd.forEach(::add)
+    }
+
+    override fun onChange(registrant: Any, callback: (Set<T>) -> Unit) {
+        observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
+        backing.onChange(this to registrant) { callback(it.keys.toSet()) }
+    }
+
+    override fun stopWatching(registrant: Any) {
+        backing.stopWatching(this to registrant)
+        observingCallbacks.remove(registrant)
+    }
+
+    override fun dispose() {
+        backing.dispose()
+        observableSize.dispose()
+        observingCallbacks.clear()
+    }
+
+    override fun observeMembership(item: T): Observable<Boolean> = backing[item].map { opt -> opt.getOrElse { false } }
+
+    override fun toSet(): Set<T> = Collections.unmodifiableSet(backing.current.keys)
+
+    override fun toList(): List<T> = backing.current.keys.toList()
+
+    override fun copy(): ObservableMutableSet<T> = ObservableMutableSet<T>().apply {
+        this@ObservableMutableSet.backing.asMap().keys.forEach(this::add)
+    }
+
+    override operator fun contains(item: T): Boolean = item in backing.current
+
+    /**
+     * Adds an item to the observable set.
+     * If the item does not already exist in the set, it will be added, and observers
+     * of the set will be notified of the change.
+     *
+     * @param item The item to be added to the set.
+     */
+    operator fun plus(item: T) = add(item)
+
+    /**
+     * Removes the specified item from the observable set.
+     * This method serves as an operator overload for the `-` operator, allowing
+     * items to be removed from the set using concise syntax. If the item exists
+     * in the set, it will be removed and observers of the set will be notified.
+     *
+     * @param item The item to be removed from the set.
+     */
+    operator fun minus(item: T) = remove(item)
+
+    /**
+     * A companion object for the `ObservableMutableSet` class, providing handy factories.
+     */
+    companion object {
+
+        /**
+         * Converts the current list into an observable mutable set.
+         * @see ObservableMutableSet
+         *
+         * @return An instance of `ObservableMutableSet` containing all unique elements from the original list.
+         */
+        fun <T> List<T>.toObservableSet(): ObservableMutableSet<T> = ObservableMutableSet<T>().also {
+            this.forEach(it::add)
+        }
+
+        /**
+         * Converts the current set into an observable mutable set.
+         * @see ObservableMutableSet
+         *
+         * @return An instance of `ObservableMutableSet` containing all the elements from the original set.
+         */
+        fun <T> Set<T>.toObservableSet(): ObservableMutableSet<T> = ObservableMutableSet<T>().also {
+            this.forEach(it::add)
+        }
+
+        /**
+         * Creates a new [ObservableMutableSet] and populates it with the specified items.
+         *
+         * @param items The items to be added to the newly created `ObservableMutableSet`.
+         * The items are provided as a variable number of arguments.
+         * @return A new [ObservableMutableSet] containing the specified items.
+         */
+        operator fun <T> invoke(vararg items: T): ObservableMutableSet<T> = ObservableMutableSet<T>().apply {
+            items.forEach(this::add)
+        }
+    }
+}
diff --git a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableListTest.kt b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableListTest.kt
new file mode 100644
index 0000000000..525487173a
--- /dev/null
+++ b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableListTest.kt
@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.collections.shouldContainExactly
+import io.kotest.matchers.shouldBe
+import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableListExtensions.combineLatest
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableListExtensions.flatMap
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableListExtensions.merge
+import it.unibo.alchemist.model.observation.ObservableMutableList.Companion.toObservableList
+
+class ObservableListTest : FunSpec({
+    context("ObservableList factories tests") {
+
+        test("an observable list can be created with varargs") {
+            val list = ObservableList(1, 2, 3)
+
+            with(list.toList()) {
+                this shouldContainExactly listOf(1, 2, 3)
+                this.size shouldBe 3
+            }
+
+            (1 in list) shouldBe true
+            (4 in list) shouldBe false
+        }
+
+        test("List.toObservableList should create observable list with same elements and order") {
+            val src = listOf(1, 2, 2, 3, 3, 3)
+
+            val list = src.toObservableList()
+
+            with(list.toList()) {
+                this shouldContainExactly listOf(1, 2, 2, 3, 3, 3)
+                this.size shouldBe 6
+            }
+        }
+    }
+
+    context("basic list operations tests") {
+        test("add should notify observers") {
+            val list = ObservableMutableList<Int>()
+
+            val seen = mutableListOf<List<Int>>()
+
+            list.onChange(this) { seen.add(it) }
+
+            list.add(1)
+            list.add(2)
+            list.add(1) // duplicates allowed
+
+            seen.size shouldBe 4
+            seen[0] shouldContainExactly emptyList()
+            seen[1] shouldContainExactly listOf(1)
+            seen[2] shouldContainExactly listOf(1, 2)
+            seen[3] shouldContainExactly listOf(1, 2, 1)
+        }
+
+        test("add at index should insert and notify") {
+            val list = ObservableMutableList(1, 3)
+            val seen = mutableListOf<List<Int>>()
+            list.onChange(this) { seen.add(it) }
+
+            list.add(1, 2)
+
+            seen.size shouldBe 2
+            list.toList() shouldContainExactly listOf(1, 2, 3)
+        }
+
+        test("addAll should append collection and notify") {
+            val list = ObservableMutableList(1)
+            val seen = mutableListOf<List<Int>>()
+            list.onChange(this) { seen.add(it) }
+
+            list.addAll(listOf(2, 3))
+
+            seen.size shouldBe 2
+            list.toList() shouldContainExactly listOf(1, 2, 3)
+        }
+
+        test("list size should be observable") {
+            val list = ObservableMutableList(1, 2, 3)
+            var nextExpected = 3
+
+            list.observableSize.onChange(this) { it shouldBe nextExpected }
+
+            repeat(3) {
+                nextExpected++
+                list.add(it + 100)
+            }
+        }
+
+        test("remove should notify observers only when element is present") {
+            val list = ObservableMutableList("a", "b", "c")
+
+            val seen = mutableListOf<List<String>>()
+            list.onChange(this) { seen.add(it) }
+
+            seen.size shouldBe 1
+            seen[0] shouldContainExactly listOf("a", "b", "c")
+
+            list.remove("b")
+            list.remove("x")
+
+            seen.size shouldBe 2
+            seen[1] shouldContainExactly listOf("a", "c")
+        }
+
+        test("removeAt should remove by index and notify") {
+            val list = ObservableMutableList("a", "b", "c")
+            val seen = mutableListOf<List<String>>()
+            list.onChange(this) { seen.add(it) }
+
+            list.removeAt(1)
+
+            seen.size shouldBe 2
+            seen[1] shouldContainExactly listOf("a", "c")
+        }
+
+        test("set should replace element and notify") {
+            val list = ObservableMutableList("a", "b", "c")
+            val seen = mutableListOf<List<String>>()
+            list.onChange(this) { seen.add(it) }
+
+            list[1] = "z"
+            list[1] = "z"
+
+            seen.size shouldBe 2
+            seen[1] shouldContainExactly listOf("a", "z", "c")
+        }
+
+        test("copy should create independent list with same elements") {
+            val original = ObservableMutableList(1, 2, 3)
+
+            val copy = original.copy()
+
+            original.toList() shouldContainExactly copy.toList()
+
+            copy.add(4)
+            copy.remove(1)
+
+            original.toList() shouldContainExactly listOf(1, 2, 3)
+            copy.toList() shouldContainExactly listOf(2, 3, 4)
+        }
+
+        test("clear should empty the list and notify") {
+            val list = ObservableMutableList(1, 2, 3)
+            val seen = mutableListOf<List<Int>>()
+            list.onChange(this) { seen.add(it) }
+
+            list.clear()
+
+            seen.last() shouldContainExactly emptyList()
+            list.toList() shouldContainExactly emptyList()
+        }
+    }
+
+    context("ObservableList extensions") {
+        test("combineLatest should aggregate mapped observables") {
+            val list = ObservableMutableList("a", "b")
+            val sources = mapOf(
+                "a" to observe(1),
+                "b" to observe(2),
+                "c" to observe(3),
+            )
+
+            val combined = list.combineLatest(
+                map = { sources[it] ?: observe(-1) },
+                aggregator = { it.sum() },
+            )
+
+            var currentSum = 0
+            combined.onChange(this) { currentSum = it }
+
+            currentSum shouldBe 3
+
+            list.add("c")
+            currentSum shouldBe 6
+
+            sources["a"]?.update { 10 }
+            currentSum shouldBe 15
+
+            list.remove("b")
+            currentSum shouldBe 13
+        }
+
+        test("flatMap should flatten observable") {
+            val list = ObservableMutableList("a")
+            val sources = mapOf(
+                "a" to observe("A"),
+                "b" to observe("B"),
+            )
+
+            val flattened = list.flatMap { sources[it] ?: observe("") }
+
+            var currentVal = ""
+            flattened.onChange(this) { currentVal = it.map { v -> v }.getOrNull() ?: "NONE" }
+
+            currentVal shouldBe "A"
+
+            list.add(0, "b")
+            currentVal shouldBe "B"
+
+            sources["b"]?.update { "Z" }
+            currentVal shouldBe "Z"
+
+            list.clear()
+            flattened.current shouldBe arrow.core.none()
+        }
+
+        test("merging a list should emit updates both for list and members") {
+            val sources = listOf(observe(10), observe(20), observe(30))
+            val list: ObservableMutableList<Observable<Int>> = sources.toObservableList()
+
+            var changeCounter = 0
+            list.merge().onChange(this) { changeCounter++ }
+
+            val baseline = changeCounter
+            sources[0].update { it + 100 }
+            changeCounter shouldBe baseline + 1
+
+            list.add(observe(40))
+            changeCounter shouldBe baseline + 2
+        }
+    }
+
+    context("list operators tests") {
+        test("plusAssign and minusAssign operators should mirror add and remove") {
+            val list = ObservableMutableList<Int>()
+
+            list += 1
+            list += 2
+            list.toList() shouldContainExactly listOf(1, 2)
+
+            list -= 1
+            list.toList() shouldContainExactly listOf(2)
+        }
+    }
+})
diff --git a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableMapTest.kt b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableMapTest.kt
new file mode 100644
index 0000000000..5ba80fedba
--- /dev/null
+++ b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableMapTest.kt
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import arrow.core.Option
+import arrow.core.getOrElse
+import arrow.core.none
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.maps.shouldContainExactly
+import io.kotest.matchers.shouldBe
+import it.unibo.alchemist.model.observation.ObservableMutableMap.ObservableMapExtensions.upsertValue
+
+class ObservableMapTest : FunSpec({
+    context("basic map operations") {
+        test("put should insert and update values and notify map observers only on real changes") {
+            val map = ObservableMutableMap<String, Int>()
+
+            val seen = mutableListOf<Map<String, Int>>()
+            map.onChange(this) { seen.add(it) }
+
+            seen.size shouldBe 1
+            seen[0].isEmpty() shouldBe true
+
+            map.put("a", 1)
+            map.put("b", 2)
+            map.put("b", 3)
+            map.put("b", 3) // duplicate, should not change
+
+            seen.size shouldBe 4
+            seen[1] shouldContainExactly mapOf("a" to 1)
+            seen[2] shouldContainExactly mapOf("a" to 1, "b" to 2)
+            seen[3] shouldContainExactly mapOf("a" to 1, "b" to 3)
+
+            map.asMap() shouldContainExactly mapOf("a" to 1, "b" to 3)
+        }
+
+        test("set operator and plus operator should delegate to put") {
+            val map = ObservableMutableMap<String, Int>()
+
+            map["a"] = 1
+            map + ("b" to 2)
+
+            map.asMap() shouldContainExactly mapOf("a" to 1, "b" to 2)
+        }
+
+        test("remove and minus should notify observers only when key exists") {
+            val map = ObservableMutableMap<String, Int>()
+
+            val seen = mutableListOf<Map<String, Int>>()
+            map.onChange(this) { seen.add(it) }
+
+            map["a"] = 1
+            map["b"] = 2
+
+            seen[1] shouldContainExactly mapOf("a" to 1)
+            seen[2] shouldContainExactly mapOf("a" to 1, "b" to 2)
+
+            map.remove("b")
+            map.remove("b")
+            map - "x"
+
+            seen.last() shouldContainExactly mapOf("a" to 1)
+        }
+
+        test("get(key) observable should emit None when absent, Some when present, and track updates") {
+            val map = ObservableMutableMap<String, Int>()
+
+            val obs: Observable<Option<Int>> = map["k"]
+
+            val seen = mutableListOf<Option<Int>>()
+            obs.onChange(this) { seen.add(it) }
+
+            seen[0] shouldBe none()
+
+            map["k"] = 42
+            map["k"] = 100
+
+            seen.size shouldBe 3
+            seen[1].getOrElse { -1 } shouldBe 42
+            seen[2].getOrElse { -1 } shouldBe 100
+
+            map.remove("k")
+
+            seen.size shouldBe 4
+            seen[3] shouldBe none()
+        }
+
+        test("copy should produce independent map with same entries") {
+            val original = ObservableMutableMap(
+                mutableMapOf("a" to 1, "b" to 2),
+            )
+
+            val copy = original.copy()
+
+            original.asMap() shouldContainExactly copy.asMap()
+
+            copy["c"] = 3
+            copy.remove("a")
+
+            original.asMap() shouldContainExactly mapOf("a" to 1, "b" to 2)
+            copy.asMap() shouldContainExactly mapOf("b" to 2, "c" to 3)
+        }
+
+        context("ObservableMap extension utils tests") {
+
+            test("upsertValue should insert when key is missing") {
+                with(ObservableMutableMap<String, Int>()) {
+                    upsertValue("k") { curr -> (curr ?: 0) + 1 }
+                    asMap() shouldContainExactly mapOf("k" to 1)
+                }
+            }
+
+            test("upsertValue should update when key exists") {
+                with(ObservableMutableMap<String, Int>()) {
+                    this["k"] = 10
+                    upsertValue("k") { curr -> (curr ?: 0) + 5 }
+                    asMap() shouldContainExactly mapOf("k" to 15)
+                }
+            }
+        }
+    }
+})
diff --git a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableSetTest.kt b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableSetTest.kt
new file mode 100644
index 0000000000..93180575e8
--- /dev/null
+++ b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableSetTest.kt
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
+import io.kotest.matchers.shouldBe
+import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.filter
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.merge
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.union
+import it.unibo.alchemist.model.observation.ObservableMutableSet.Companion.toObservableSet
+
+class ObservableSetTest : FunSpec({
+    context("ObservableSet factories tests") {
+
+        test("an observable set can be created with varaargs") {
+            val set = ObservableSet(1, 2, 3)
+
+            with(set.toSet()) {
+                this shouldContainExactlyInAnyOrder listOf(1, 2, 3)
+                this.size shouldBe 3
+            }
+
+            (1 in set) shouldBe true
+            (4 in set) shouldBe false
+        }
+
+        test("List.toObservableSet should create observable set with unique elements") {
+            val list = listOf(1, 2, 2, 3, 3, 3)
+
+            val set = list.toObservableSet()
+
+            with(set.toSet()) {
+                this shouldContainExactlyInAnyOrder listOf(1, 2, 3)
+                this.size shouldBe 3
+            }
+        }
+
+        test("Set.toObservableSet should preserve all elements") {
+            val src = setOf("a", "b", "c")
+
+            val set = src.toObservableSet()
+
+            with(set.toSet()) {
+                this shouldContainExactlyInAnyOrder listOf("a", "b", "c")
+                this.size shouldBe 3
+            }
+        }
+    }
+
+    context("basic set operations tests") {
+        test("add should notify observers only on real changes") {
+            val set = ObservableMutableSet<Int>()
+
+            val seen = mutableListOf<Set<Int>>()
+
+            set.onChange(this) { seen.add(it) }
+
+            set.add(1)
+            set.add(2)
+            set.add(2) // duplicate, should not change
+
+            seen.size shouldBe 3
+            seen[1] shouldContainExactlyInAnyOrder listOf(1)
+            seen[2] shouldContainExactlyInAnyOrder listOf(1, 2)
+        }
+
+        test("set size should be observable") {
+            val set = ObservableMutableSet(1, 2, 3)
+            var nextExpected = 3
+
+            set.observableSize.onChange(this) { it shouldBe nextExpected }
+
+            repeat(3) {
+                nextExpected++
+                set.add(it + 100)
+            }
+        }
+
+        test("remove should notify observers only when element is present") {
+            val set = ObservableMutableSet("a", "b", "c")
+
+            val seen = mutableListOf<Set<String>>()
+            set.onChange(this) { seen.add(it) }
+
+            seen.size shouldBe 1
+            seen[0] shouldContainExactlyInAnyOrder listOf("a", "b", "c")
+
+            set.remove("b")
+            set.remove("b")
+            set.remove("x")
+
+            seen.size shouldBe 2
+            seen[1] shouldContainExactlyInAnyOrder listOf("a", "c")
+        }
+
+        test("observeMembership should emit false when element not present and true when added") {
+            val set = ObservableMutableSet<String>()
+
+            val membership = set.observeMembership("foo")
+
+            val seen = mutableListOf<Boolean>()
+            membership.onChange(this) { seen.add(it) }
+
+            set.add("foo")
+            set.add("foo")
+
+            seen.size shouldBe 2
+            seen[1] shouldBe true
+
+            set.remove("foo")
+            seen.size shouldBe 3
+            seen[2] shouldBe false
+        }
+
+        test("copy should create independent set with same elements") {
+            val original = ObservableMutableSet(1, 2, 3)
+
+            val copy = original.copy()
+
+            original.toSet() shouldContainExactlyInAnyOrder copy.toSet()
+
+            copy.add(4)
+            copy.remove(1)
+
+            original.toSet() shouldContainExactlyInAnyOrder listOf(1, 2, 3)
+            copy.toSet() shouldContainExactlyInAnyOrder listOf(2, 3, 4)
+        }
+    }
+
+    context("ObservableSet extensions") {
+
+        test("filter should filter set elements") {
+            val set = ObservableMutableSet(1, 2, 3, 4, 5)
+            set.filter { it % 2 == 0 }.toSet() shouldContainExactlyInAnyOrder listOf(2, 4)
+        }
+
+        test("merging a set should emit updates both for sets and members") {
+            val sources = listOf(observe(10), observe(20), observe(30))
+            val set: ObservableSet<Observable<Int>> = sources.toObservableSet()
+
+            var changeCounter = 0
+            set.merge().onChange(this) { changeCounter++ }
+
+            val baseline = changeCounter
+            sources[0].update { it + 100 }
+            changeCounter shouldBe baseline + 1
+        }
+    }
+
+    context("set operators tests") {
+        test("plus and minus operators should mirror add and remove") {
+            val set = ObservableMutableSet<Int>()
+
+            set + 1
+            set + 2
+            (1 in set) shouldBe true
+            (2 in set) shouldBe true
+            (3 in set) shouldBe false
+
+            set - 1
+            (1 in set) shouldBe false
+            (2 in set) shouldBe true
+        }
+
+        test("union should perform set union of two sets") {
+            val s1 = ObservableSet(1, 2, 3)
+            val s2 = ObservableSet(2, 3, 4)
+
+            (s1 union s2).toSet() shouldContainExactlyInAnyOrder setOf(1, 2, 3, 4)
+        }
+    }
+})
diff --git a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableTest.kt b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableTest.kt
new file mode 100644
index 0000000000..59de8e7b9b
--- /dev/null
+++ b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableTest.kt
@@ -0,0 +1,541 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import arrow.core.Option
+import arrow.core.getOrElse
+import arrow.core.none
+import arrow.core.some
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.collections.shouldContain
+import io.kotest.matchers.collections.shouldContainExactly
+import io.kotest.matchers.collections.shouldHaveSize
+import io.kotest.matchers.comparables.shouldBeGreaterThan
+import io.kotest.matchers.shouldBe
+import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
+import it.unibo.alchemist.model.observation.MutableObservable.Companion.updateValue
+import it.unibo.alchemist.model.observation.Observable.ObservableExtensions.asMutable
+import it.unibo.alchemist.model.observation.Observable.ObservableExtensions.currentOrNull
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.combineLatest
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.flatMap
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.merge
+import it.unibo.alchemist.model.observation.ObservableExtensions.combineLatest
+
+class ObservableTest : FunSpec({
+    context("base `Observable` tests") {
+        test("`onChange` should immediately emit current value to the observer") {
+            val observable = observe(42)
+            var lastSeen: Int? = null
+
+            observable.onChange(this) { lastSeen = it }
+
+            lastSeen shouldBe 42
+        }
+
+        test("`update` should return previous value and update current") {
+            val observable = observe(0)
+
+            val old = observable.update { it + 5 }
+
+            old shouldBe 0
+            observable.current shouldBe 5
+        }
+
+        test("it should be possibile to observe changes of a value") {
+            val observable = observe(10)
+
+            var changesCount = -1 // first sub always calls observing callbacks
+            observable.onChange(this) { changesCount++ }
+
+            repeat(10) {
+                observable.update { curr -> curr + 10 }
+            }
+
+            changesCount shouldBe 10
+        }
+
+        test("it should be possible to stop watching an observable") {
+            val observable = observe(10)
+            var changesCount = -1
+            observable.onChange(this) { changesCount++ }
+
+            repeat(10) {
+                observable.update { curr -> curr + 10 }
+            }
+
+            observable.stopWatching(this)
+
+            repeat(10) {
+                observable.update { curr -> curr + 10 }
+            }
+
+            changesCount shouldBe 10
+        }
+
+        test("an observable should not notify observers if `dispose` has been called") {
+            val observable = observe(10)
+            var changesCount = -1
+            observable.onChange(this) { changesCount++ }
+
+            repeat(10) {
+                observable.update { curr -> curr + 10 }
+            }
+
+            observable.dispose()
+
+            repeat(10) {
+                observable.update { curr -> curr + 10 }
+            }
+
+            changesCount shouldBe 10
+        }
+
+        test("observers emission should be idempotent") {
+            val observable = observe(10)
+            var changesCount = -1
+            observable.onChange(this) { changesCount++ }
+
+            repeat(10) { _ ->
+                observable.update { it } // update the value with itself
+            }
+
+            changesCount shouldBe 0
+        }
+
+        test("multiple registrants should all be notified") {
+            val observable = observe(0)
+
+            var aCount = -1
+            var bCount = -1
+
+            val registrantA = "A"
+            val registrantB = "B"
+
+            observable.onChange(registrantA) { aCount++ }
+            observable.onChange(registrantB) { bCount++ }
+
+            repeat(3) { observable.update { curr -> curr + 1 } }
+
+            aCount shouldBe 3
+            bCount shouldBe 3
+
+            observable.observers shouldContain registrantA
+            observable.observers shouldContain registrantB
+        }
+
+        test("same registrant can have multiple callbacks") {
+            val observable = observe(0)
+
+            var sum = 0
+            var count = -1
+
+            val registrant = "same-registrant"
+
+            observable.onChange(registrant) { sum += it }
+            observable.onChange(registrant) { count++ }
+
+            repeat(3) { observable.update { curr -> curr + 1 } }
+
+            sum shouldBe (1 + 2 + 3)
+            count shouldBe 3
+        }
+
+        test("it should be possibile to map an observable into another") {
+            val observable = observe(10)
+            val strObservable = observable.map { it.toString() }
+
+            var changesCounts = -1
+
+            strObservable.onChange(this) { changesCounts++ }
+
+            repeat(10) { observable.update { curr -> curr + 10 } }
+
+            changesCounts shouldBe 10
+            strObservable.current shouldBe "${10 * 11}"
+        }
+
+        test("a mapped observable should be idempotent wrt mapped values") {
+            val observable = observe(0)
+            val parityObservable = observable.map { it % 2 == 0 }
+
+            var emissions = -1
+            parityObservable.onChange(this) { emissions++ }
+
+            // Sequence that keeps parity constant: 0 -> 2 -> 4 -> 6
+            repeat(3) {
+                observable.update { curr -> curr + 2 }
+            }
+
+            emissions shouldBe 0
+        }
+
+        test("it should be possibile to merge an observable into another") {
+            val a = observe(0)
+            val b = observe(0)
+
+            val c = a.mergeWith(b) { first, second -> first + second }
+
+            var current = 0
+            c.onChange(this) { current = it }
+
+            a.update { it + 10 }
+            current shouldBe 10
+            b.update { it + 10 }
+            current shouldBe 20
+        }
+
+        test("a merged observable should be idempotent wrt merged values") {
+            val a = observe(0)
+            val b = observe(0)
+
+            val c = a.mergeWith(b) { first, second -> (first + second) % 2 }
+
+            var emissions = -1
+            c.onChange(this) { emissions++ }
+
+            repeat(5) { _ ->
+                a.update { it + 2 }
+                b.update { it + 2 }
+            }
+
+            emissions shouldBe 0
+        }
+    }
+
+    context("`Observable` extensions tests") {
+
+        test("`combineLatest` should emit combined value when any source changes") {
+            val a = observe(1)
+            val b = observe(10)
+
+            val collected: MutableObservable<Option<String>> =
+                listOf<Observable<Int>>(a, b).combineLatest { values ->
+                    "${values[0]}-${values[1]}"
+                }.asMutable()
+
+            val emissions = mutableListOf<String>()
+
+            collected.onChange(this) { emissions.add(it.getOrElse { "" }) }
+
+            a.update { it + 1 }
+            b.update { it + 5 }
+
+            emissions[1] shouldBe "2-10"
+            emissions[2] shouldBe "2-15"
+        }
+
+        test("`combineLatest` should be idempotent wrt collected result") {
+            val a = observe(0)
+            val b = observe(0)
+
+            val collected: MutableObservable<Option<Int>> =
+                listOf<Observable<Int>>(a, b).combineLatest { values ->
+                    (values[0] + values[1]) % 2
+                }.asMutable()
+
+            var emissions = -1
+            collected.onChange(this) { emissions++ }
+
+            repeat(5) { _ ->
+                a.update { it + 2 }
+                b.update { it + 4 }
+            }
+
+            emissions shouldBe 0
+        }
+
+        test("`combineLatest` should unsubscribe sources when last observer stops watching") {
+            val a = observe(1)
+            val b = observe(2)
+
+            val collected: MutableObservable<Option<Int>> =
+                listOf<Observable<Int>>(a, b).combineLatest { values ->
+                    values.sum()
+                }.asMutable()
+
+            val registrant = "collector-observer"
+
+            a.observers.size shouldBe 0
+            b.observers.size shouldBe 0
+
+            collected.onChange(registrant) { }
+
+            a.observers.size shouldBeGreaterThan 0
+            b.observers.size shouldBeGreaterThan 0
+
+            collected.stopWatching(registrant)
+
+            a.observers.size shouldBe 0
+            b.observers.size shouldBe 0
+        }
+
+        context("`Obsevable<Option<T>>` extensions tests") {
+
+            test("`currentOrNull` should work as expected") {
+                val someObs = observe(10.some())
+                val noneObs = observe(none<Int>())
+
+                someObs.currentOrNull() shouldBe 10
+                noneObs.currentOrNull() shouldBe null
+            }
+
+            test("`updateValue` should update the inner Option") {
+                val someObs = observe(1.some())
+                val noneObs = observe(none<Int>())
+
+                listOf(someObs, noneObs).forEach { obs -> obs.updateValue { it + 1 } }
+
+                someObs.current shouldBe 2.some()
+                noneObs.current shouldBe none()
+            }
+        }
+
+        context("`combineLatest`") {
+
+            test("should aggregate inner observable values and react to both set and inner changes") {
+                val set = ObservableMutableSet<String>()
+
+                val inner = mutableMapOf<String, MutableObservable<Int>>()
+
+                fun observableFor(key: String): Observable<Int> = inner.getOrPut(key) { observe(0) }
+
+                val combined = set.combineLatest(map = ::observableFor, aggregator = { values -> values.sum() })
+
+                val seen = mutableListOf<Int>()
+                combined.onChange(this) { seen.add(it) }
+
+                seen[0] shouldBe 0
+
+                set.add("a")
+                set.add("b")
+
+                seen.last() shouldBe 0
+
+                inner["a"]!!.update { 10 }
+                inner["b"]!!.update { 5 }
+
+                seen shouldContainExactly listOf(0, 10, 15)
+
+                set.remove("a")
+
+                seen.last() shouldBe 5
+            }
+
+            test("should unsubscribe from removed elements' observables on stopWatching") {
+                val set = ObservableMutableSet<String>()
+                val inner = mutableMapOf<String, MutableObservable<Int>>()
+
+                fun observableFor(key: String): Observable<Int> = inner.getOrPut(key) { observe(0) }
+
+                set.add("x")
+                set.add("y")
+
+                val combined = set.combineLatest(map = ::observableFor, aggregator = { values -> values.sum() })
+
+                val registrant = "test-registrant"
+                combined.onChange(registrant) { }
+
+                inner["x"]!!.observers.shouldHaveSize(1)
+                inner["y"]!!.observers.shouldHaveSize(1)
+
+                combined.stopWatching(registrant)
+
+                inner["x"]!!.observers.shouldHaveSize(0)
+                inner["y"]!!.observers.shouldHaveSize(0)
+            }
+        }
+
+        context("flatMap") {
+
+            test("should emit current values of newly added elements and react to their emissions") {
+                val set = ObservableMutableSet<String>()
+
+                val inner = mutableMapOf<String, MutableObservable<Int>>()
+
+                fun observableFor(key: String): Observable<Int> = inner.getOrPut(key) { observe(0) }
+
+                set.add("a")
+                val fused = set.flatMap(::observableFor)
+
+                val seen = mutableListOf<Int>()
+                fused.onChange(this) { seen.add(it.getOrElse { -1 }) }
+
+                seen[0] shouldBe 0
+
+                inner["b"] = observe(10)
+                set.add("b")
+                inner["b"]!!.update { 20 }
+                set.add("c")
+
+                //                                         a,  b,  b, c
+                seen.shouldContainExactly(listOf(0, 10, 20, 0))
+            }
+
+            test("should unsubscribe from inner observables on stopWatching") {
+                val set = ObservableMutableSet("a")
+                val inner = mutableMapOf<String, MutableObservable<Int>>()
+
+                fun observableFor(key: String): Observable<Int> = inner.getOrPut(key) { observe(0) }
+
+                val fused = set.flatMap(::observableFor)
+                fused.onChange(this) { }
+                set.add("b")
+
+                inner["a"]!!.observers.shouldHaveSize(1)
+                inner["b"]!!.observers.shouldHaveSize(1)
+
+                fused.stopWatching(this)
+
+                inner["a"]!!.observers.shouldHaveSize(0)
+                inner["b"]!!.observers.shouldHaveSize(0)
+            }
+        }
+
+        test("should emit None immediately if the source ObservableSet is empty") {
+            val set = ObservableMutableSet<String>()
+            val fused = set.flatMap { observe(10) }
+            val seen = mutableListOf<Option<Int>>()
+
+            fused.onChange(this) { seen.add(it) }
+
+            seen shouldContainExactly listOf(none())
+        }
+
+        test("should emit None when the set becomes empty (after having been non-empty)") {
+            val set = ObservableMutableSet("a")
+            val inner = mutableMapOf<String, MutableObservable<Int>>()
+
+            fun observableFor(key: String): Observable<Int> = inner.getOrPut(key) { observe(0) }
+
+            val fused = set.flatMap(::observableFor)
+
+            val seen = mutableListOf<Option<Int>>()
+            fused.onChange(this) { seen.add(it) }
+
+            inner["a"]!!.update { 7 }
+            set.remove("a")
+
+            seen shouldContainExactly listOf(0.some(), 7.some(), none())
+        }
+    }
+
+    context("merge") {
+        test("a merged observable set should emit on membership and members emissions") {
+            val obsA = observe(10)
+            val obsB = observe(-10)
+            val elements = ObservableMutableSet(obsA, obsB)
+            val merged = elements.merge()
+
+            var counter = -elements.toSet().size
+            merged.onChange(this) {
+                println(it)
+                counter++
+            }
+
+            obsA.update { it + 11 }
+            elements.add(observe(29))
+
+            counter shouldBe 2
+        }
+
+        test("merge should emit None immediately if the set is empty") {
+            val set = ObservableMutableSet<Observable<Int>>()
+            val merged = set.merge()
+
+            val seen = mutableListOf<Any?>()
+            merged.onChange(this) { seen.add(it.getOrNull()) }
+
+            seen shouldContainExactly listOf(null)
+        }
+
+        test("merge should emit None when set becomes empty, then Some when it becomes non-empty again") {
+            val a = observe(1)
+            val set = ObservableMutableSet<Observable<Int>>(a)
+            val merged = set.merge()
+
+            val seen = mutableListOf<Any?>()
+            merged.onChange(this) { seen.add(it.getOrNull()) }
+
+            set.remove(a)
+            val b = observe(9)
+            set.add(b)
+
+            seen shouldContainExactly listOf(1, null, 9)
+        }
+    }
+
+    context("`EventObservers` tests") {
+        test("EventObservable emit should notify all observers every time") {
+            val event = EventObservable()
+
+            var calls = -1
+            event.onChange(this) { calls++ }
+
+            repeat(5) { event.emit() }
+
+            calls shouldBe 5
+        }
+
+        test("EventObservable should support multiple registrants") {
+            val event = EventObservable()
+
+            var aCalls = -1
+            var bCalls = -1
+
+            val registrantA = "A"
+            val registrantB = "B"
+
+            event.onChange(registrantA) { aCalls++ }
+            event.onChange(registrantB) { bCalls++ }
+
+            repeat(3) { event.emit() }
+
+            aCalls shouldBe 3
+            bCalls shouldBe 3
+
+            event.observers.size shouldBe 2
+        }
+
+        test("EventObservable stopWatching should remove the registrant") {
+            val event = EventObservable()
+            val registrant = "R"
+
+            var calls = -1
+            event.onChange(registrant) { calls++ }
+
+            event.emit()
+            event.stopWatching(registrant)
+            event.emit()
+
+            calls shouldBe 1
+            event.observers.contains(registrant) shouldBe false
+        }
+
+        test("EventObservable dispose should remove all observers and prevent further notifications") {
+            val event = EventObservable()
+
+            var calls = -2
+            val registrant1 = "R1"
+            val registrant2 = "R2"
+
+            event.onChange(registrant1) { calls++ }
+            event.onChange(registrant2) { calls++ }
+
+            event.emit()
+
+            event.dispose()
+
+            event.emit()
+
+            calls shouldBe 2
+            event.observers.isEmpty() shouldBe true
+        }
+    }
+})
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/AbstractEngine.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/AbstractEngine.kt
new file mode 100644
index 0000000000..edc32f9dd1
--- /dev/null
+++ b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/AbstractEngine.kt
@@ -0,0 +1,371 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.core
+
+import it.unibo.alchemist.boundary.OutputMonitor
+import it.unibo.alchemist.model.Actionable
+import it.unibo.alchemist.model.Environment
+import it.unibo.alchemist.model.Position
+import it.unibo.alchemist.model.Time
+import java.util.Collections
+import java.util.Optional
+import java.util.concurrent.BlockingQueue
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.locks.Condition
+import java.util.concurrent.locks.Lock
+import java.util.concurrent.locks.ReentrantLock
+import java.util.function.BooleanSupplier
+import org.jooq.lambda.fi.lang.CheckedRunnable
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+/**
+ * Abstract base class for simulation engines, providing common functionality for
+ * status management, time tracking, command scheduling, and output monitoring.
+ *
+ * @param T the concentration type
+ * @param P the position type
+ * @property environment the simulation environment
+ */
+abstract class AbstractEngine<T, P : Position<out P>>(private val environment: Environment<T, P>) : Simulation<T, P> {
+
+    private val statusLock: Lock = ReentrantLock()
+
+    /** Lock for synchronizing access to the simulation status. */
+    @Volatile private var status: Status = Status.INIT
+
+    /** Tracks errors that occurred during simulation execution. */
+    private var error: Optional<Throwable> = Optional.empty()
+
+    /** Current simulation time. */
+    protected var currentTime: Time = Time.ZERO
+        @Synchronized get
+
+        @Synchronized set
+
+    /** Current simulation step count. */
+    protected var currentStep: Long = 0
+        @Synchronized get
+
+        @Synchronized set
+
+    /** Thread executing the simulation. */
+    private var simulationThread: Thread? = null
+
+    /** Locks associated with each simulation status. */
+    protected val statusLocks: Map<Status, SynchBox> = Status.entries.associateWith { SynchBox() }
+
+    /** Queue of scheduled simulation commands. */
+    protected val commands: BlockingQueue<CheckedRunnable> = LinkedBlockingQueue()
+
+    /** List of registered output monitors for simulation events. */
+    protected val monitors: MutableList<OutputMonitor<T, P>> = CopyOnWriteArrayList()
+
+    init {
+        LOGGER.trace("Engine created")
+        environment.simulation = this
+    }
+
+    /**
+     * Adds an output monitor to track simulation events.
+     *
+     * @param op the [OutputMonitor] to add
+     */
+    override fun addOutputMonitor(op: OutputMonitor<T, P>) {
+        monitors.add(op)
+    }
+
+    /**
+     * @param op the OutputMonitor to remove
+     */
+    override fun removeOutputMonitor(op: OutputMonitor<T, P>) {
+        monitors.remove(op)
+    }
+
+    /** @return the list of registered output monitors. */
+    override fun getOutputMonitors(): List<OutputMonitor<T, P>> = Collections.unmodifiableList(monitors)
+
+    /** @return the simulation environment. */
+    override fun getEnvironment(): Environment<T, P> = environment
+
+    /** @return the last error encountered, if any. */
+    override fun getError(): Optional<Throwable> = error
+
+    protected fun setError(error: Optional<Throwable>) {
+        this.error = error
+    }
+
+    /** @return the current simulation status. */
+    override fun getStatus(): Status = status
+
+    protected fun setStatus(status: Status) {
+        this.status = status
+    }
+
+    /** @return the current step (thread-safe). */
+    @Synchronized override fun getStep(): Long = currentStep
+
+    /** @return the current simulation time (thread-safe). */
+    @Synchronized override fun getTime(): Time = currentTime
+
+    /**
+     * Moves the simulation forward until the given step is reached.
+     *
+     * @param step the target step to execute up to.
+     * @return a [CompletableFuture] that completes once the step is reached.
+     */
+    override fun goToStep(step: Long): CompletableFuture<Unit> = pauseWhen { getStep() >= step }
+
+    /**
+     * Moves the simulation forward until the given time is reached.
+     *
+     * @param t the target simulation time.
+     * @return a [CompletableFuture] that completes once the time is reached.
+     */
+    override fun goToTime(t: Time): CompletableFuture<Unit> = pauseWhen { time >= t }
+
+    /** Pauses the simulation. */
+    override fun pause(): CompletableFuture<Unit> = newStatus(Status.PAUSED)
+
+    /** Resumes the simulation. */
+    override fun play(): CompletableFuture<Unit> = newStatus(Status.RUNNING)
+
+    /** Terminates the simulation. */
+    override fun terminate(): CompletableFuture<Unit> = newStatus(Status.TERMINATED)
+
+    /**
+     * Waits for the simulation to reach a given status.
+     *
+     * @param next the [Status] the simulation should reach before returning
+     * @param timeout the maximum time to wait
+     * @param tu the [TimeUnit] defining the timeout
+     * @return the current simulation status
+     */
+    override fun waitFor(next: Status, timeout: Long, tu: TimeUnit): Status =
+        lockForStatus(next).waitFor(next, timeout, tu)
+
+    /**
+     * Schedules a task for execution.
+     *
+     * @param runnable the task to execute
+     */
+    override fun schedule(runnable: CheckedRunnable) {
+        check(status != Status.TERMINATED) { "This simulation is terminated and cannot be resumed." }
+        commands.add(runnable)
+    }
+
+    /** Ensures that the method is called from the simulation thread. */
+    protected fun checkCaller() {
+        check(Thread.currentThread() == simulationThread) {
+            "This method must be called from the simulation thread."
+        }
+    }
+
+    /**
+     * Executes an action while holding the status lock.
+     *
+     * @param action the action to execute
+     * @return the result of the action
+     */
+    protected fun <R> doOnStatus(action: () -> R): R = statusLock.run {
+        lock()
+        try {
+            action()
+        } finally {
+            unlock()
+        }
+    }
+
+    /**
+     * Updates the simulation status.
+     *
+     * @param next the new status to set
+     * @return a future that completes when the status is updated
+     */
+    protected open fun newStatus(next: Status): CompletableFuture<Unit> {
+        val future = CompletableFuture<Unit>()
+        schedule {
+            doOnStatus {
+                if (next.isReachableFrom(status)) {
+                    status = next
+                    lockForStatus(next).releaseAll()
+                }
+                future.complete(null)
+            }
+        }
+        return future
+    }
+
+    protected fun processCommandsWhileIn(status: Status) {
+        while (this.status == status) {
+            processCommand(commands.take())
+        }
+    }
+
+    protected open fun processCommand(command: CheckedRunnable) {
+        command.run()
+    }
+
+    /**
+     * Retrieves the synchronization lock for a given status.
+     *
+     * @param futureStatus the status to obtain a lock for
+     * @return the corresponding synchronization lock
+     * @throws IllegalStateException if the requested status lock does not exist
+     */
+    private fun lockForStatus(futureStatus: Status): SynchBox = checkNotNull(statusLocks[futureStatus]) {
+        "Inconsistent state: the Alchemist engine tried to synchronize on a non-existing lock. " +
+            "Searching for status: $futureStatus, available locks: $statusLocks"
+    }
+
+    /**
+     * Pauses the simulation when the given condition is met.
+     *
+     * @param condition the condition to trigger the pause
+     * @return a [CompletableFuture] that completes when the simulation is paused
+     */
+    private fun pauseWhen(condition: BooleanSupplier): CompletableFuture<Unit> {
+        val future = CompletableFuture<Unit>()
+        val monitor = object : OutputMonitor<T, P> {
+            @Volatile
+            private var hasTriggered = false
+
+            override fun initialized(initializedEnvironment: Environment<T, P>) {
+                checkConditionAndPause()
+            }
+
+            override fun stepDone(
+                targetEnvironment: Environment<T, P>,
+                reaction: Actionable<T>?,
+                time: Time,
+                step: Long,
+            ) {
+                checkConditionAndPause()
+            }
+
+            private fun checkConditionAndPause() {
+                if (!hasTriggered && condition.asBoolean) {
+                    hasTriggered = true
+                    monitors.remove(this)
+                    pause().thenRun { future.complete(null) }
+                }
+            }
+        }
+        addOutputMonitor(monitor)
+        return future
+    }
+
+    /**
+     * Internal method to run the simulation loop.
+     * Implementations must provide [initialize], [doStep], and hooks for run cycle.
+     */
+    @Suppress("TooGenericExceptionCaught")
+    override fun run() {
+        synchronized(environment) {
+            try {
+                val logger = LoggerFactory.getLogger(this::class.java)
+                logger.info("Starting engine {} with scheduler", this::class.java.simpleName)
+                simulationThread = Thread.currentThread()
+
+                initialize()
+
+                status = Status.READY
+                logger.trace("Thread {} started running.", Thread.currentThread().id)
+                monitors.forEach { it.initialized(environment) }
+                processCommandsWhileIn(Status.READY)
+                while (status != Status.TERMINATED && time < Time.INFINITY) {
+                    while (commands.isNotEmpty()) {
+                        processCommand(commands.poll())
+                    }
+                    if (status == Status.RUNNING) {
+                        doStep()
+                    }
+                    processCommandsWhileIn(Status.PAUSED)
+                }
+            } catch (e: Throwable) {
+                error = Optional.of(e)
+                LoggerFactory.getLogger(this::class.java).error("The simulation engine crashed.", e)
+            } finally {
+                status = Status.TERMINATED
+                commands.clear()
+                try {
+                    monitors.forEach { it.finished(environment, time, step) }
+                } catch (e: Throwable) {
+                    error.ifPresentOrElse({ it.addSuppressed(e) }, { error = Optional.of(e) })
+                }
+                afterRun()
+            }
+        }
+    }
+
+    protected abstract fun initialize()
+
+    /**
+     * Performs a single step of the simulation.
+     */
+    protected abstract fun doStep()
+
+    /** Override this to execute custom logic after the simulation run. */
+    protected open fun afterRun() = Unit
+
+    /** @return a string representation of the engine. */
+    override fun toString(): String = "${javaClass.simpleName} t: $time, s: $step"
+
+    /**
+     * Synchronization helper for status transitions.
+     */
+    protected inner class SynchBox {
+        private val queueLength = AtomicInteger()
+        private val statusReached: Condition = statusLock.newCondition()
+        private val allReleased: Condition = statusLock.newCondition()
+
+        /**
+         * Waits for the specified status until the timeout expires.
+         *
+         * @param next the target status
+         * @param timeout the maximum time to wait
+         * @param tu the time unit for the timeout
+         * @return the current status after waiting
+         */
+        fun waitFor(next: Status, timeout: Long, tu: TimeUnit): Status = doOnStatus {
+            var notTimedOut = true
+            while (notTimedOut && next != status && next.isReachableFrom(status)) {
+                try {
+                    queueLength.incrementAndGet()
+                    notTimedOut = statusReached.await(timeout, tu)
+                    queueLength.decrementAndGet()
+                } catch (e: InterruptedException) {
+                    LOGGER.info("Spurious wakeup?", e)
+                }
+            }
+            if (queueLength.get() == 0) allReleased.signal()
+            status
+        }
+
+        /** Releases all locks. */
+        fun releaseAll() {
+            doOnStatus {
+                while (queueLength.get() != 0) {
+                    statusReached.signalAll()
+                    allReleased.awaitUninterruptibly()
+                }
+            }
+        }
+    }
+
+    protected companion object {
+        /** Logger instance. */
+        val LOGGER: Logger = LoggerFactory.getLogger(Engine::class.java)
+    }
+}
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
index 3b6a20e5fb..42a01a4a5e 100644
--- a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
+++ b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
@@ -8,9 +8,7 @@
  */
 package it.unibo.alchemist.core
 
-import com.google.common.collect.ImmutableList
 import com.google.common.collect.Sets
-import it.unibo.alchemist.boundary.OutputMonitor
 import it.unibo.alchemist.model.Actionable
 import it.unibo.alchemist.model.Context
 import it.unibo.alchemist.model.Dependency
@@ -19,23 +17,9 @@ import it.unibo.alchemist.model.Neighborhood
 import it.unibo.alchemist.model.Node
 import it.unibo.alchemist.model.Position
 import it.unibo.alchemist.model.Reaction
-import it.unibo.alchemist.model.Time
 import java.util.ArrayDeque
-import java.util.Optional
 import java.util.Queue
-import java.util.concurrent.BlockingQueue
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.CopyOnWriteArrayList
-import java.util.concurrent.LinkedBlockingQueue
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.atomic.AtomicInteger
-import java.util.concurrent.locks.Condition
-import java.util.concurrent.locks.Lock
-import java.util.concurrent.locks.ReentrantLock
-import java.util.function.BooleanSupplier
 import org.jooq.lambda.fi.lang.CheckedRunnable
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
 
 /**
  * Represents a simulation engine that manages execution and scheduling.
@@ -49,45 +33,13 @@ import org.slf4j.LoggerFactory
 open class Engine<T, P : Position<out P>>(
     private val environment: Environment<T, P>,
     protected val scheduler: Scheduler<T>,
-) : Simulation<T, P> {
-
-    private val statusLock: Lock = ReentrantLock()
-
-    /** Lock for synchronizing access to the simulation status. */
-    @Volatile private var status: Status = Status.INIT
-
-    /** Tracks errors that occurred during simulation execution. */
-    private var error: Optional<Throwable> = Optional.empty()
-
-    /** Current simulation time. */
-    protected var currentTime: Time = Time.ZERO
-        @Synchronized get
-
-        @Synchronized set
-
-    /** Current simulation step count. */
-    protected var currentStep: Long = 0
-        @Synchronized get
-
-        @Synchronized set
-
-    /** Thread executing the simulation. */
-    private var simulationThread: Thread? = null
-
-    /** Locks associated with each simulation status. */
-    protected val statusLocks: Map<Status, SynchBox> = Status.entries.associateWith { SynchBox() }
-
-    /** Queue of scheduled simulation commands. */
-    private val commands: BlockingQueue<CheckedRunnable> = LinkedBlockingQueue()
+) : AbstractEngine<T, P>(environment) {
 
     /** Queue of updates to be processed after execution. */
     protected val afterExecutionUpdates: Queue<Update> = ArrayDeque()
 
     /** Manages dependencies between reactions in the simulation. */
-    protected val dependencyGraph: DependencyGraph<T>
-
-    /** List of registered output monitors for simulation events. */
-    protected val monitors: MutableList<OutputMonitor<T, P>> = CopyOnWriteArrayList()
+    protected val dependencyGraph: DependencyGraph<T> = JGraphTDependencyGraph(environment)
 
     /**
      * Constructs a simulation with a default scheduler.
@@ -99,41 +51,12 @@ open class Engine<T, P : Position<out P>>(
      */
     constructor(environment: Environment<T, P>) : this(environment, ArrayIndexedPriorityQueue())
 
-    init {
-        LOGGER.trace("Engine created")
-        environment.simulation = this
-        dependencyGraph = JGraphTDependencyGraph(environment)
-    }
-
-    /**
-     * Adds an output monitor to track simulation events.
-     *
-     * @param op the [OutputMonitor] to add
-     */
-    override fun addOutputMonitor(op: OutputMonitor<T, P>) {
-        monitors.add(op)
-    }
-
-    /** Ensures that the method is called from the simulation thread. */
-    private fun checkCaller() {
-        check(this::class.java == BatchEngine::class.java || Thread.currentThread() == simulationThread) {
-            "This method must be called from the simulation thread."
-        }
-    }
-
-    private fun <R> doOnStatus(action: () -> R): R = statusLock.run {
-        lock()
-        try {
-            action()
-        } finally {
-            unlock()
-        }
+    override fun initialize() {
+        environment.globalReactions.forEach { reactionAdded(it) }
+        environment.forEach { node -> node.reactions.forEach { scheduleReaction(it) } }
     }
 
-    /**
-     * Performs a single step of the simulation.
-     */
-    protected open fun doStep() {
+    override fun doStep() {
         val nextEvent = scheduler.getNext() ?: run {
             newStatus(Status.TERMINATED)
             LOGGER.info("No more reactions.")
@@ -165,37 +88,6 @@ open class Engine<T, P : Position<out P>>(
         currentStep = step + 1
     }
 
-    /** @return the simulation environment. */
-    override fun getEnvironment(): Environment<T, P> = environment
-
-    /** @return the last error encountered, if any. */
-    override fun getError(): Optional<Throwable> = error
-
-    /** @return the current simulation status. */
-    override fun getStatus(): Status = status
-
-    /** @return the current step (thread-safe). */
-    @Synchronized override fun getStep(): Long = currentStep
-
-    /** @return the current simulation time (thread-safe). */
-    @Synchronized override fun getTime(): Time = currentTime
-
-    /**
-     * Moves the simulation forward until the given step is reached.
-     *
-     * @param step the target step to execute up to.
-     * @return a [CompletableFuture] that completes once the step is reached.
-     */
-    override fun goToStep(step: Long): CompletableFuture<Unit> = pauseWhen { getStep() >= step }
-
-    /**
-     * Moves the simulation forward until the given time is reached.
-     *
-     * @param t the target simulation time.
-     * @return a [CompletableFuture] that completes once the time is reached.
-     */
-    override fun goToTime(t: Time): CompletableFuture<Unit> = pauseWhen { time >= t }
-
     /**
      * Registers a newly added neighbor.
      *
@@ -218,26 +110,6 @@ open class Engine<T, P : Position<out P>>(
         afterExecutionUpdates.add(NeighborRemoved(node, n))
     }
 
-    /**
-     * Updates the simulation status.
-     *
-     * @param next the new status to set
-     * @return a future that completes when the status is updated
-     */
-    protected open fun newStatus(next: Status): CompletableFuture<Unit> {
-        val future = CompletableFuture<Unit>()
-        schedule {
-            doOnStatus {
-                if (next.isReachableFrom(status)) {
-                    status = next
-                    lockForStatus(next).releaseAll()
-                }
-                future.complete(null)
-            }
-        }
-        return future
-    }
-
     /**
      * Handles the addition of a new node.
      *
@@ -269,12 +141,6 @@ open class Engine<T, P : Position<out P>>(
         afterExecutionUpdates.add(NodeRemoval(node))
     }
 
-    /** Pauses the simulation. */
-    override fun pause(): CompletableFuture<Unit> = newStatus(Status.PAUSED)
-
-    /** Resumes the simulation. */
-    override fun play(): CompletableFuture<Unit> = newStatus(Status.RUNNING)
-
     /**
      * Registers a newly added reaction.
      *
@@ -307,7 +173,7 @@ open class Engine<T, P : Position<out P>>(
     private fun reactionsToUpdateAfterExecution(): Sequence<Actionable<T>> =
         afterExecutionUpdates.asSequence().flatMap { it.reactionsToUpdate }.distinct()
 
-    private fun processCommand(command: CheckedRunnable) {
+    override fun processCommand(command: CheckedRunnable) {
         command.run()
         val updated = mutableSetOf<Actionable<T>>()
         reactionsToUpdateAfterExecution().forEach {
@@ -319,108 +185,6 @@ open class Engine<T, P : Position<out P>>(
         reactionsToUpdateAfterExecution().forEach { if (it !in updated) updateReaction(it) }
     }
 
-    /**
-     * @param op the OutputMonitor to add
-     */
-    override fun removeOutputMonitor(op: OutputMonitor<T, P>) {
-        monitors.remove(op)
-    }
-
-    private fun processCommandsWhileIn(status: Status) {
-        while (this.status == status) {
-            processCommand(commands.take())
-        }
-    }
-
-    /**
-     * Runs the simulation.
-     */
-    @Suppress("TooGenericExceptionCaught")
-    override fun run() {
-        synchronized(environment) {
-            try {
-                LOGGER.info("Starting engine {} with scheduler {}", javaClass, scheduler.javaClass)
-                simulationThread = Thread.currentThread()
-                environment.globalReactions.forEach { reactionAdded(it) }
-                environment.forEach { node -> node.reactions.forEach { scheduleReaction(it) } }
-                status = Status.READY
-                LOGGER.trace("Thread {} started running.", Thread.currentThread().id)
-                monitors.forEach { it.initialized(environment) }
-                processCommandsWhileIn(Status.READY)
-                while (status != Status.TERMINATED && time < Time.INFINITY) {
-                    while (commands.isNotEmpty()) {
-                        processCommand(commands.poll())
-                    }
-                    if (status == Status.RUNNING) {
-                        doStep()
-                    }
-                    processCommandsWhileIn(Status.PAUSED)
-                }
-            } catch (e: Throwable) { // NOPMD: forced by CheckedRunnable
-                error = Optional.of(e)
-                LOGGER.error("The simulation engine crashed.", e)
-            } finally {
-                status = Status.TERMINATED
-                commands.clear()
-                try {
-                    monitors.forEach { it.finished(environment, time, step) }
-                } catch (e: Throwable) { // NOPMD: we need to catch everything
-                    error.ifPresentOrElse({ it.addSuppressed(e) }, { error = Optional.of(e) })
-                }
-                afterRun()
-            }
-        }
-    }
-
-    /** Override this to execute custom logic after the simulation run. */
-    protected fun afterRun() = Unit
-
-    /**
-     * Pauses the simulation when the given condition is met.
-     *
-     * @param condition the condition to trigger the pause
-     * @return a [CompletableFuture] that completes when the simulation is paused
-     */
-    private fun pauseWhen(condition: BooleanSupplier): CompletableFuture<Unit> {
-        val future = CompletableFuture<Unit>()
-        val monitor = object : OutputMonitor<T, P> {
-            @Volatile
-            private var hasTriggered = false
-
-            override fun initialized(initializedEnvironment: Environment<T, P>) {
-                checkConditionAndPause()
-            }
-            override fun stepDone(
-                targetEnvironment: Environment<T, P>,
-                reaction: Actionable<T>?,
-                time: Time,
-                step: Long,
-            ) {
-                checkConditionAndPause()
-            }
-
-            private fun checkConditionAndPause() {
-                if (!hasTriggered && condition.asBoolean) {
-                    hasTriggered = true
-                    monitors.remove(this)
-                    pause().thenRun { future.complete(null) }
-                }
-            }
-        }
-        addOutputMonitor(monitor)
-        return future
-    }
-
-    /**
-     * Schedules a task for execution.
-     *
-     * @param runnable the task to execute
-     */
-    override fun schedule(runnable: CheckedRunnable) {
-        check(status != Status.TERMINATED) { "This simulation is terminated and cannot be resumed." }
-        commands.add(runnable)
-    }
-
     /**
      * Schedules a reaction by setting up dependencies and adding it to the scheduler.
      *
@@ -432,12 +196,6 @@ open class Engine<T, P : Position<out P>>(
         scheduler.addReaction(reaction)
     }
 
-    /** Terminates the simulation. */
-    override fun terminate(): CompletableFuture<Unit> = newStatus(Status.TERMINATED)
-
-    /** @return a string representation of the engine. */
-    override fun toString(): String = "${javaClass.simpleName} t: $time, s: $step"
-
     /**
      * Updates the given reaction, adjusting its scheduling if needed.
      *
@@ -449,32 +207,6 @@ open class Engine<T, P : Position<out P>>(
         if (r.tau != previousTau) scheduler.updateReaction(r)
     }
 
-    /**
-     * Retrieves the synchronization lock for a given status.
-     *
-     * @param futureStatus the status to obtain a lock for
-     * @return the corresponding synchronization lock
-     * @throws IllegalStateException if the requested status lock does not exist
-     */
-    private fun lockForStatus(futureStatus: Status): SynchBox = checkNotNull(statusLocks[futureStatus]) {
-        "Inconsistent state: the Alchemist engine tried to synchronize on a non-existing lock. " +
-            "Searching for status: $futureStatus, available locks: $statusLocks"
-    }
-
-    /**
-     * Waits for the simulation to reach a given status.
-     *
-     * @param next the [Status] the simulation should reach before returning
-     * @param timeout the maximum time to wait
-     * @param tu the [TimeUnit] defining the timeout
-     * @return the current simulation status
-     */
-    override fun waitFor(next: Status, timeout: Long, tu: TimeUnit): Status =
-        lockForStatus(next).waitFor(next, timeout, tu)
-
-    /** @return the list of registered output monitors. */
-    override fun getOutputMonitors(): List<OutputMonitor<T, P>> = ImmutableList.copyOf(monitors)
-
     /**
      * Represents a simulation update operation.
      */
@@ -535,13 +267,6 @@ open class Engine<T, P : Position<out P>>(
         override val reactionsToUpdate: Sequence<Actionable<T>> = sequenceOf(sourceReaction)
     }
 
-    /** Handles the addition of a reaction. */
-    private inner class ReactionAddition(source: Actionable<T>) : AbstractUpdateOnReaction(source) {
-        override fun performChanges() {
-            this@Engine.scheduleReaction(sourceReaction)
-        }
-    }
-
     /** Handles the removal of a reaction. */
     private inner class ReactionRemoval(source: Actionable<T>) : AbstractUpdateOnReaction(source) {
         override fun performChanges() {
@@ -550,6 +275,13 @@ open class Engine<T, P : Position<out P>>(
         }
     }
 
+    /** Handles the addition of a reaction. */
+    private inner class ReactionAddition(source: Actionable<T>) : AbstractUpdateOnReaction(source) {
+        override fun performChanges() {
+            this@Engine.scheduleReaction(sourceReaction)
+        }
+    }
+
     /**
      * Handles neighborhood changes, ensuring updates to relevant reactions.
      *
@@ -584,51 +316,4 @@ open class Engine<T, P : Position<out P>>(
             dependencyGraph.removeNeighbor(sourceNode, targetNode)
         }
     }
-
-    /**
-     * Synchronization helper for status transitions.
-     */
-    protected inner class SynchBox {
-        private val queueLength = AtomicInteger()
-        private val statusReached: Condition = statusLock.newCondition()
-        private val allReleased: Condition = statusLock.newCondition()
-
-        /**
-         * Waits for the specified status until the timeout expires.
-         *
-         * @param next the target status
-         * @param timeout the maximum time to wait
-         * @param tu the time unit for the timeout
-         * @return the current status after waiting
-         */
-        fun waitFor(next: Status, timeout: Long, tu: TimeUnit): Status = doOnStatus {
-            var notTimedOut = true
-            while (notTimedOut && next != status && next.isReachableFrom(status)) {
-                try {
-                    queueLength.incrementAndGet()
-                    notTimedOut = statusReached.await(timeout, tu)
-                    queueLength.decrementAndGet()
-                } catch (e: InterruptedException) {
-                    LOGGER.info("Spurious wakeup?", e)
-                }
-            }
-            if (queueLength.get() == 0) allReleased.signal()
-            status
-        }
-
-        /** Releases all locks. */
-        fun releaseAll() {
-            doOnStatus {
-                while (queueLength.get() != 0) {
-                    statusReached.signalAll()
-                    allReleased.awaitUninterruptibly()
-                }
-            }
-        }
-    }
-
-    private companion object {
-        /** Logger instance. */
-        val LOGGER: Logger = LoggerFactory.getLogger(Engine::class.java)
-    }
 }
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/ReactiveEngine.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/ReactiveEngine.kt
new file mode 100644
index 0000000000..72e0858d09
--- /dev/null
+++ b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/ReactiveEngine.kt
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.core
+
+import it.unibo.alchemist.model.Actionable
+import it.unibo.alchemist.model.Environment
+import it.unibo.alchemist.model.Neighborhood
+import it.unibo.alchemist.model.Node
+import it.unibo.alchemist.model.Position
+
+/**
+ * A reactive implementation of the [Simulation] engine.
+ * This engine does not use a dependency graph. Instead, it relies on [Actionable]s
+ * (Reactions) being reactive based on what they [observe][it.unibo.alchemist.model.observation.Observable].
+ * Sources' (nodes' contents, positions, neighborhoods, ...) changes will automatically trigger reactions
+ * updates and reschedules.
+ *
+ * @param T the concentration type
+ * @param P the position type, extending [Position]
+ * @property environment the simulation environment
+ * @property scheduler the scheduler managing event execution
+ */
+open class ReactiveEngine<T, P : Position<out P>>(
+    private val environment: Environment<T, P>,
+    protected val scheduler: Scheduler<T>,
+) : AbstractEngine<T, P>(environment) {
+
+    constructor(environment: Environment<T, P>) : this(environment, ArrayIndexedPriorityQueue())
+
+    override fun initialize() {
+        environment.globalReactions.forEach(::scheduleReaction)
+        environment.forEach { it.reactions.forEach(::scheduleReaction) }
+    }
+
+    override fun doStep() {
+        val nextEvent = scheduler.getNext() ?: run {
+            terminate()
+            LOGGER.info("No more reactions.")
+            return
+        }
+        val scheduledTime = nextEvent.tau
+        check(scheduledTime >= time) {
+            "$nextEvent is scheduled in the past at time $scheduledTime. Current time: $time; current step: $step."
+        }
+        currentTime = scheduledTime
+        if (scheduledTime.isFinite && nextEvent.canExecute()) {
+            nextEvent.conditions.forEach { it.reactionReady() }
+            nextEvent.execute()
+        }
+        nextEvent.update(time, true, environment)
+        scheduler.updateReaction(nextEvent)
+
+        monitors.forEach { it.stepDone(environment, nextEvent, time, step) }
+        if (environment.isTerminated) {
+            terminate()
+            LOGGER.info("Termination condition reached.")
+        }
+        currentStep = step + 1
+    }
+
+    /* No dependency graph to update */
+    override fun neighborAdded(node: Node<T>, n: Node<T>) = Unit
+
+    override fun neighborRemoved(node: Node<T>, n: Node<T>) = Unit
+
+    override fun nodeMoved(node: Node<T>) = Unit
+
+    override fun nodeAdded(node: Node<T>) {
+        schedule {
+            node.reactions.forEach { scheduleReaction(it) }
+        }
+    }
+
+    override fun nodeRemoved(node: Node<T>, oldNeighborhood: Neighborhood<T>) {
+        schedule {
+            node.reactions.forEach { removeReaction(it) }
+        }
+    }
+
+    override fun reactionAdded(reactionToAdd: Actionable<T>) {
+        schedule { scheduleReaction(reactionToAdd) }
+    }
+
+    override fun reactionRemoved(reactionToRemove: Actionable<T>) {
+        schedule { removeReaction(reactionToRemove) }
+    }
+
+    private fun scheduleReaction(reaction: Actionable<T>) {
+        reaction.initializationComplete(time, environment)
+        scheduler.addReaction(reaction)
+
+        reaction.rescheduleRequest.onChange(this) {
+            updateReaction(reaction)
+        }
+    }
+
+    protected fun updateReaction(reaction: Actionable<T>) {
+        val previousTau = reaction.tau
+        reaction.update(time, false, environment)
+        if (reaction.tau != previousTau) {
+            scheduler.updateReaction(reaction)
+        }
+    }
+
+    private fun removeReaction(reaction: Actionable<T>) {
+        reaction.rescheduleRequest.stopWatching(this)
+        scheduler.removeReaction(reaction)
+    }
+}
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/AbstractDependencyTest.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/AbstractDependencyTest.kt
new file mode 100644
index 0000000000..e401e784dd
--- /dev/null
+++ b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/AbstractDependencyTest.kt
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.core
+
+import io.kotest.core.spec.style.StringSpec
+import it.unibo.alchemist.core.util.DependencyUtils.withIncarnation
+import it.unibo.alchemist.core.util.DependencyUtils.withRandom
+import it.unibo.alchemist.model.Environment
+import it.unibo.alchemist.model.Node
+import it.unibo.alchemist.model.Reaction
+import it.unibo.alchemist.model.biochemistry.BiochemistryIncarnation
+import org.apache.commons.math3.random.MersenneTwister
+
+abstract class AbstractDependencyTest : StringSpec() {
+
+    abstract fun Reaction<Double>.assertDependencies(vararg dependencies: Reaction<Double>)
+
+    open fun beforeTest(environment: Environment<Double, *>) {}
+
+    init {
+        "local reactions on separate nodes should be isolated" {
+            withRandom(MersenneTwister(10)) {
+                withIncarnation(BiochemistryIncarnation()) {
+                    val reactions: MutableMap<Int, Map<String, Reaction<Double>>> = mutableMapOf()
+                    val environment =
+                        environment {
+                            fun Node<Double>.configureNode(): Map<String, Reaction<Double>> = listOf(
+                                "[a]-->[b]",
+                                "[a]-->[c]",
+                                "[b]-->[c]",
+                                "[c]-->[b]",
+                            ).associateWith { reaction(it) }
+
+                            node(0, 0) {
+                                val map = configureNode()
+                                reactions += id to map
+                                setConcentration(incarnation.createMolecule("a"), 1.0)
+                                setConcentration(incarnation.createMolecule("b"), 1.0)
+                                setConcentration(incarnation.createMolecule("c"), 1.0)
+                            }
+
+                            node(0.5, 0) {
+                                val map = configureNode()
+                                reactions += id to map
+                                setConcentration(incarnation.createMolecule("a"), 1.0)
+                                setConcentration(incarnation.createMolecule("b"), 1.0)
+                                setConcentration(incarnation.createMolecule("c"), 1.0)
+                            }
+                        }
+
+                    beforeTest(environment)
+
+                    fun String.inNode(id: Int): Reaction<Double> = reactions.getValue(id).getValue(this)
+
+                    (0..1).forEach { id ->
+                        "[a]-->[b]".inNode(id).assertDependencies(
+                            "[a]-->[c]".inNode(id),
+                            "[b]-->[c]".inNode(id),
+                        )
+
+                        "[a]-->[c]".inNode(id).assertDependencies(
+                            "[a]-->[b]".inNode(id),
+                            "[c]-->[b]".inNode(id),
+                        )
+
+                        "[b]-->[c]".inNode(id).assertDependencies(
+                            "[c]-->[b]".inNode(id),
+                        )
+
+                        "[c]-->[b]".inNode(id).assertDependencies(
+                            "[b]-->[c]".inNode(id),
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/AbstractEngineTest.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/AbstractEngineTest.kt
new file mode 100644
index 0000000000..c7dbe7cbf5
--- /dev/null
+++ b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/AbstractEngineTest.kt
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.core
+
+import io.kotest.core.spec.style.FreeSpec
+import io.kotest.matchers.shouldBe
+import it.unibo.alchemist.core.util.DependencyUtils
+import it.unibo.alchemist.model.Environment
+import it.unibo.alchemist.model.biochemistry.BiochemistryIncarnation
+import it.unibo.alchemist.model.biochemistry.molecules.Biomolecule
+import it.unibo.alchemist.model.conditions.NeighborHasConcentration
+import it.unibo.alchemist.model.environments.Continuous2DEnvironment
+import it.unibo.alchemist.model.linkingrules.ConnectWithinDistance
+import it.unibo.alchemist.model.nodes.GenericNode
+import it.unibo.alchemist.model.timedistributions.DiracComb
+import it.unibo.alchemist.model.times.DoubleTime
+
+@Suppress("UnnecessaryAbstractClass")
+abstract class AbstractEngineTest(
+    val engineFactory: (Environment<Double, *>) -> Simulation<Double, *>,
+) : FreeSpec({
+
+    "Neighbor Condition: Reaction executes when neighbor has concentration" {
+        val incarnation = BiochemistryIncarnation()
+        val environment = Continuous2DEnvironment(incarnation)
+        environment.linkingRule = ConnectWithinDistance(2.0)
+
+        val nodeA = GenericNode(environment)
+        val nodeB = GenericNode(environment)
+        val molM = Biomolecule("M")
+        val molN = Biomolecule("N")
+
+        nodeA.setConcentration(molN, 0.0)
+        nodeB.setConcentration(molM, 0.0)
+
+        nodeB.addReaction(
+            DependencyUtils.SimpleReaction(nodeB, DiracComb(1.0)) {
+                nodeB.setConcentration(molM, 1.0)
+            },
+        )
+
+        DependencyUtils.SimpleReaction(nodeA, DiracComb(1.0)) {
+            nodeA.setConcentration(molN, 1.0)
+        }.apply {
+            conditions = listOf(NeighborHasConcentration(nodeA, environment, molM, 1.0))
+            nodeA.addReaction(this)
+        }
+
+        environment.addNode(nodeA, environment.makePosition(0, 0))
+        environment.addNode(nodeB, environment.makePosition(1, 0))
+
+        environment.addTerminator { it.simulation.time > DoubleTime(5.0) }
+
+        val engine = engineFactory(environment)
+        engine.play()
+        engine.run()
+
+        if (engine.error.isPresent) {
+            throw engine.error.get()
+        }
+
+        // B should have M=1.0 (from Node B's Reaction)
+        nodeB.getConcentration(molM) shouldBe 1.0
+
+        // A should have N=1.0 (executed after observing B)
+        nodeA.getConcentration(molN) shouldBe 1.0
+    }
+})
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestDependencyGraph.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestDependencyGraph.kt
index d8221b834e..1425bba0a3 100644
--- a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestDependencyGraph.kt
+++ b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestDependencyGraph.kt
@@ -9,116 +9,20 @@
 
 package it.unibo.alchemist.core
 
-import io.kotest.core.spec.style.StringSpec
 import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
 import it.unibo.alchemist.model.Environment
-import it.unibo.alchemist.model.Incarnation
-import it.unibo.alchemist.model.Node
 import it.unibo.alchemist.model.Reaction
-import it.unibo.alchemist.model.biochemistry.BiochemistryIncarnation
-import it.unibo.alchemist.model.environments.Continuous2DEnvironment
-import it.unibo.alchemist.model.linkingrules.ConnectWithinDistance
-import it.unibo.alchemist.model.positions.Euclidean2DPosition
-import it.unibo.alchemist.model.timedistributions.ExponentialTime
-import org.apache.commons.math3.random.MersenneTwister
-import org.apache.commons.math3.random.RandomGenerator
 
-private data class RandomContext(
-    val randomGenerator: RandomGenerator,
-)
+class TestDependencyGraph : AbstractDependencyTest() {
 
-private data class IncarnationContext<T>(
-    val randomGenerator: RandomGenerator,
-    val incarnation: Incarnation<T, Euclidean2DPosition>,
-) {
-    fun environment(configuration: EnvironmentContext<T>.() -> Unit): Environment<T, Euclidean2DPosition> =
-        EnvironmentContext(
-            randomGenerator,
-            incarnation,
-            Continuous2DEnvironment(incarnation).apply {
-                linkingRule = ConnectWithinDistance(1.0)
-            },
-        ).apply(configuration).environment
-}
-
-private data class EnvironmentContext<T>(
-    val randomGenerator: RandomGenerator,
-    val incarnation: Incarnation<T, Euclidean2DPosition>,
-    val environment: Environment<T, Euclidean2DPosition>,
-) {
-    fun Node<T>.reaction(configuration: String): Reaction<T> = incarnation
-        .createReaction(
-            randomGenerator,
-            environment,
-            this,
-            ExponentialTime(1.0, randomGenerator),
-            configuration,
-        ).also { addReaction(it) }
-
-    fun node(x: Number, y: Number, configuration: Node<T>.() -> Unit): Node<T> =
-        incarnation.createNode(randomGenerator, environment, null).apply {
-            configuration()
-            environment.addNode(this, environment.makePosition(x, y))
-        }
-}
+    private lateinit var graph: DependencyGraph<Double>
 
-private fun withRandom(randomGenerator: RandomGenerator, block: RandomContext.() -> Unit) {
-    RandomContext(randomGenerator).block()
-}
+    override fun beforeTest(environment: Environment<Double, *>) {
+        graph = JGraphTDependencyGraph(environment)
+        environment.nodes.flatMap { it.reactions }.forEach { graph.createDependencies(it) }
+    }
 
-private fun <T> RandomContext.withIncarnation(
-    incarnation: Incarnation<T, Euclidean2DPosition>,
-    block: IncarnationContext<T>.() -> Unit,
-) {
-    IncarnationContext(randomGenerator, incarnation).block()
+    override fun Reaction<Double>.assertDependencies(vararg dependencies: Reaction<Double>) {
+        graph.outboundDependencies(this).toList() shouldContainExactlyInAnyOrder dependencies.toList()
+    }
 }
-
-class TestDependencyGraph :
-    StringSpec(
-        {
-            withRandom(MersenneTwister(10)) {
-                withIncarnation(BiochemistryIncarnation()) {
-                    val reactions: MutableMap<Int, Map<String, Reaction<Double>>> = mutableMapOf()
-                    val environment =
-                        environment {
-                            fun Node<Double>.configureNode(): Map<String, Reaction<Double>> = listOf(
-                                "[a]-->[b]",
-                                "[a]-->[c]",
-                                "[b]-->[c]",
-                                "[c]-->[b]",
-                            ).associateWith { reaction(it) }
-                            node(0, 0) { reactions += id to configureNode() }
-                            node(0.5, 0) { reactions += id to configureNode() }
-                        }
-
-                    fun String.inNode(id: Int): Reaction<Double> = reactions.getValue(id).getValue(this)
-                    with(JGraphTDependencyGraph(environment)) {
-                        reactions.asSequence().flatMap { it.value.asSequence() }.map { it.value }.forEach {
-                            createDependencies(it)
-                        }
-
-                        fun Reaction<Double>.mustHaveOutBoundDependencies(vararg dependencies: Reaction<Double>) =
-                            outboundDependencies(this).toList() shouldContainExactlyInAnyOrder dependencies.toList()
-                        "local reactions on separate nodes should be isolated" {
-                            (0..1).forEach { id ->
-                                "[a]-->[b]".inNode(id).mustHaveOutBoundDependencies(
-                                    "[a]-->[c]".inNode(id),
-                                    "[b]-->[c]".inNode(id),
-                                )
-                                "[a]-->[c]".inNode(id).mustHaveOutBoundDependencies(
-                                    "[a]-->[b]".inNode(id),
-                                    "[c]-->[b]".inNode(id),
-                                )
-                                "[b]-->[c]".inNode(id).mustHaveOutBoundDependencies(
-                                    "[c]-->[b]".inNode(id),
-                                )
-                                "[c]-->[b]".inNode(id).mustHaveOutBoundDependencies(
-                                    "[b]-->[c]".inNode(id),
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-        },
-    )
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineComparison.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineComparison.kt
new file mode 100644
index 0000000000..7acd1dd7c0
--- /dev/null
+++ b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineComparison.kt
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.core
+
+import io.kotest.core.spec.style.FreeSpec
+import io.kotest.matchers.collections.shouldContainExactly
+import it.unibo.alchemist.boundary.OutputMonitor
+import it.unibo.alchemist.core.util.DependencyUtils
+import it.unibo.alchemist.model.Actionable
+import it.unibo.alchemist.model.Environment
+import it.unibo.alchemist.model.Molecule
+import it.unibo.alchemist.model.Node
+import it.unibo.alchemist.model.Position
+import it.unibo.alchemist.model.Time
+import it.unibo.alchemist.model.biochemistry.BiochemistryIncarnation
+import it.unibo.alchemist.model.biochemistry.molecules.Biomolecule
+import it.unibo.alchemist.model.conditions.MoleculeHasConcentration
+import it.unibo.alchemist.model.environments.Continuous2DEnvironment
+import it.unibo.alchemist.model.linkingrules.NoLinks
+import it.unibo.alchemist.model.nodes.GenericNode
+import it.unibo.alchemist.model.timedistributions.DiracComb
+import it.unibo.alchemist.model.times.DoubleTime
+import java.util.concurrent.CopyOnWriteArrayList
+import kotlin.jvm.optionals.getOrNull
+import org.junit.jupiter.api.fail
+
+class TestEngineComparison : FreeSpec({
+
+    data class TraceEntry(val time: Double, val nodeId: Int, val molecule: String, val concentration: Double)
+
+    class TraceMonitor<T, P : Position<out P>> : OutputMonitor<T, P> {
+        val trace = CopyOnWriteArrayList<TraceEntry>()
+
+        override fun stepDone(environment: Environment<T, P>, reaction: Actionable<T>?, time: Time, step: Long) {
+            environment.nodes.forEach { node ->
+                node.contents.forEach { (mol, conc) ->
+                    trace.add(TraceEntry(time.toDouble(), node.id, mol.name, (conc as Number).toDouble()))
+                }
+            }
+        }
+    }
+
+    fun prepareEnvironment(): Continuous2DEnvironment<Double> {
+        val incarnation = BiochemistryIncarnation()
+        val environment = Continuous2DEnvironment(incarnation)
+        environment.linkingRule = NoLinks()
+        environment.addTerminator { it.simulation.time > DoubleTime(10.0) }
+        return environment
+    }
+
+    fun runAndTrace(
+        setup: (Continuous2DEnvironment<Double>) -> Unit,
+        engineFactory: (Environment<Double, *>) -> Simulation<Double, *>,
+    ): List<TraceEntry> {
+        val environment = prepareEnvironment()
+        setup(environment)
+        val monitor = TraceMonitor<Double, Position<*>>()
+
+        @Suppress("UNCHECKED_CAST")
+        val engine = engineFactory(environment as Environment<Double, *>) as Simulation<Double, Position<*>>
+        engine.addOutputMonitor(monitor)
+
+        engine.play()
+        engine.run()
+
+        engine.error.getOrNull()?.let { err ->
+            fail { "Simulation failed with an error: ${err.message}: ${err.stackTraceToString()}" }
+        }
+
+        return monitor.trace
+    }
+
+    val a = Biomolecule("A")
+    val b = Biomolecule("B")
+    val c = Biomolecule("C")
+
+    fun setupNode(env: Continuous2DEnvironment<Double>): GenericNode<Double> {
+        val node = GenericNode(env)
+        node.setConcentration(a, 1.0)
+        node.setConcentration(b, 0.0)
+        node.setConcentration(c, 0.0)
+        return node
+    }
+
+    fun addReaction(node: Node<Double>, rate: Double, conditionMolecule: Molecule, action: () -> Unit) {
+        DependencyUtils.SimpleReaction(node, DiracComb(rate)) {
+            action()
+        }.apply {
+            conditions = listOf(MoleculeHasConcentration(node, conditionMolecule, 1.0))
+            node.addReaction(this)
+        }
+    }
+
+    "Compare Engine and ReactiveEngine" - {
+        listOf(
+            "Simple Chain: A -> B -> C" to { env: Continuous2DEnvironment<Double> ->
+                val node = setupNode(env)
+                addReaction(node, 1.0, a) {
+                    node.setConcentration(a, 0.0)
+                    node.setConcentration(b, 1.0)
+                }
+                addReaction(node, 1.0, b) {
+                    node.setConcentration(b, 0.0)
+                    node.setConcentration(c, 1.0)
+                }
+                env.addNode(node, env.makePosition(0, 0))
+                Unit
+            },
+            "Simple Branching: A -> B, A -> C" to { env: Continuous2DEnvironment<Double> ->
+                val node = setupNode(env)
+                addReaction(node, 1.0, a) {
+                    node.setConcentration(b, node.getConcentration(b) + 1.0)
+                }
+                addReaction(node, 0.5, a) {
+                    node.setConcentration(c, node.getConcentration(c) + 1.0)
+                }
+                env.addNode(node, env.makePosition(0, 0))
+                Unit
+            },
+            "Simple Feedback Loop: A -> B -> A" to { env: Continuous2DEnvironment<Double> ->
+                val node = setupNode(env)
+                addReaction(node, 1.0, a) {
+                    node.setConcentration(a, 0.0)
+                    node.setConcentration(b, 1.0)
+                }
+                addReaction(node, 1.0, b) {
+                    node.setConcentration(b, 0.0)
+                    node.setConcentration(a, 1.0)
+                }
+                env.addNode(node, env.makePosition(0, 0))
+                Unit
+            },
+        ).forEach { (_, setup) ->
+            val traceEngine = runAndTrace(setup) { Engine(it) }
+            val traceReactive = runAndTrace(setup) { ReactiveEngine(it) }
+            traceReactive shouldContainExactly traceEngine
+        }
+    }
+})
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineImplementation.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineImplementation.kt
new file mode 100644
index 0000000000..052383abfe
--- /dev/null
+++ b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineImplementation.kt
@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.core
+
+class TestEngineImplementation : AbstractEngineTest({ env -> Engine(env) })
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveDependencies.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveDependencies.kt
new file mode 100644
index 0000000000..21c4c0c0b0
--- /dev/null
+++ b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveDependencies.kt
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.core
+
+import io.kotest.matchers.ints.shouldBeGreaterThan
+import io.kotest.matchers.nulls.shouldNotBeNull
+import it.unibo.alchemist.model.Environment
+import it.unibo.alchemist.model.Reaction
+import it.unibo.alchemist.model.Time
+import java.util.concurrent.atomic.AtomicInteger
+
+class TestReactiveDependencies : AbstractDependencyTest() {
+
+    private lateinit var environment: Environment<Double, *>
+
+    override fun beforeTest(environment: Environment<Double, *>) {
+        this.environment = environment
+    }
+
+    override fun Reaction<Double>.assertDependencies(vararg dependencies: Reaction<Double>) {
+        val counters = dependencies.associateWith { AtomicInteger(0) }
+
+        dependencies.forEach { target ->
+            target.initializationComplete(Time.ZERO, environment)
+            target.rescheduleRequest.onChange(this) {
+                counters[target]?.incrementAndGet()
+            }
+        }
+        this.execute()
+
+        dependencies.forEach { target ->
+            val count = counters[target]?.get()
+            count.shouldNotBeNull()
+            count shouldBeGreaterThan 0
+        }
+
+        dependencies.forEach { it.rescheduleRequest.stopWatching(this) }
+    }
+}
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveEngineImplementation.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveEngineImplementation.kt
new file mode 100644
index 0000000000..95735ed7a5
--- /dev/null
+++ b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveEngineImplementation.kt
@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.core
+
+class TestReactiveEngineImplementation : AbstractEngineTest({ env -> ReactiveEngine(env) })
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/util/DependencyUtils.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/util/DependencyUtils.kt
new file mode 100644
index 0000000000..58b316dca0
--- /dev/null
+++ b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/util/DependencyUtils.kt
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.core.util
+
+import it.unibo.alchemist.model.Environment
+import it.unibo.alchemist.model.Incarnation
+import it.unibo.alchemist.model.Node
+import it.unibo.alchemist.model.Reaction
+import it.unibo.alchemist.model.Time
+import it.unibo.alchemist.model.TimeDistribution
+import it.unibo.alchemist.model.environments.Continuous2DEnvironment
+import it.unibo.alchemist.model.linkingrules.ConnectWithinDistance
+import it.unibo.alchemist.model.positions.Euclidean2DPosition
+import it.unibo.alchemist.model.reactions.AbstractReaction
+import it.unibo.alchemist.model.timedistributions.ExponentialTime
+import org.apache.commons.math3.random.RandomGenerator
+
+object DependencyUtils {
+
+    class SimpleReaction<T>(
+        node: Node<T>,
+        distribution: TimeDistribution<T>,
+        val action: () -> Unit,
+    ) : AbstractReaction<T>(node, distribution) {
+        override fun updateInternalStatus(
+            currentTime: Time,
+            hasBeenExecuted: Boolean,
+            environment: Environment<T, *>,
+        ) = Unit
+
+        override fun cloneOnNewNode(node: Node<T>, currentTime: Time): Reaction<T> = throw NotImplementedError()
+
+        override fun execute() {
+            action()
+        }
+    }
+
+    data class RandomContext(
+        val randomGenerator: RandomGenerator,
+    )
+
+    data class IncarnationContext<T>(
+        val randomGenerator: RandomGenerator,
+        val incarnation: Incarnation<T, Euclidean2DPosition>,
+    ) {
+        fun environment(configuration: EnvironmentContext<T>.() -> Unit): Environment<T, Euclidean2DPosition> =
+            EnvironmentContext(
+                randomGenerator,
+                incarnation,
+                Continuous2DEnvironment(incarnation).apply {
+                    linkingRule = ConnectWithinDistance(1.0)
+                },
+            ).apply(configuration).environment
+    }
+
+    data class EnvironmentContext<T>(
+        val randomGenerator: RandomGenerator,
+        val incarnation: Incarnation<T, Euclidean2DPosition>,
+        val environment: Environment<T, Euclidean2DPosition>,
+    ) {
+        fun Node<T>.reaction(configuration: String): Reaction<T> = incarnation
+            .createReaction(
+                randomGenerator,
+                environment,
+                this,
+                ExponentialTime(1.0, randomGenerator),
+                configuration,
+            ).also { addReaction(it) }
+
+        fun node(x: Number, y: Number, configuration: Node<T>.() -> Unit): Node<T> =
+            incarnation.createNode(randomGenerator, environment, null).apply {
+                configuration()
+                environment.addNode(this, environment.makePosition(x, y))
+            }
+    }
+
+    fun withRandom(randomGenerator: RandomGenerator, block: RandomContext.() -> Unit) {
+        RandomContext(randomGenerator).block()
+    }
+
+    fun <T> RandomContext.withIncarnation(
+        incarnation: Incarnation<T, Euclidean2DPosition>,
+        block: IncarnationContext<T>.() -> Unit,
+    ) {
+        IncarnationContext(randomGenerator, incarnation).block()
+    }
+}
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/AbstractCondition.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/AbstractCondition.java
index 52f597726c..09aa3fa6ab 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/AbstractCondition.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/AbstractCondition.java
@@ -14,6 +14,10 @@
 import it.unibo.alchemist.model.Dependency;
 import it.unibo.alchemist.model.Node;
 import it.unibo.alchemist.model.Reaction;
+import it.unibo.alchemist.model.observation.MutableObservable;
+import it.unibo.alchemist.model.observation.Observable;
+import it.unibo.alchemist.model.observation.ObservableMutableSet;
+import it.unibo.alchemist.model.observation.ObservableSet;
 import org.danilopianini.util.LinkedListSet;
 import org.danilopianini.util.ListSet;
 import org.danilopianini.util.ListSets;
@@ -32,6 +36,18 @@ public abstract class AbstractCondition<T> implements Condition<T> {
     private final ListSet<Dependency> influencing = new LinkedListSet<>();
     private final Node<T> node;
 
+    private final ObservableMutableSet<Observable<?>> dependencies = new ObservableMutableSet<>();
+
+    /**
+     * An observable which emits this condition's validity.
+     */
+    private Observable<Boolean> validity = MutableObservable.Companion.observe(true);
+
+    /**
+     * An observable which emits this condition's propensity contribution.
+     */
+    private Observable<Double> propensity = MutableObservable.Companion.observe(0.0);
+
     /**
      * @param node the node this Condition belongs to
      */
@@ -52,6 +68,12 @@ public final ListSet<? extends Dependency> getInboundDependencies() {
         return ListSets.unmodifiableListSet(influencing);
     }
 
+    @SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "This is intentional")
+    @Override
+    public final ObservableSet<? extends Observable<?>> observeInboundDependencies() {
+        return dependencies;
+    }
+
     /**
      * {@inheritDoc}
      *
@@ -72,10 +94,75 @@ protected final void declareDependencyOn(final Dependency m) {
         influencing.add(m);
     }
 
+    /**
+     * Add the given {@link Observable} to the set of observables of this Condition.
+     *
+     * @param dep the observable to observe
+     * @return the input dependency itself
+     */
+    protected Observable<?> addObservableDependency(final Observable<?> dep) {
+        dependencies.add(dep);
+        return dep;
+    }
+
+    /**
+     * If you plan to extend this method, please consider leaving this
+     * implementation as is and use a reactive/observable style by
+     * overriding {@link #observeValidity()}.
+     *
+     * @return whether this condition is valid.
+     */
+    @Override
+    public boolean isValid() {
+        return observeValidity().getCurrent();
+    }
+
+    /**
+     * If you plan to override this method, make sure to free up additional
+     * observables in {@link #dispose()}.
+     */
+    @Override
+    public Observable<Boolean> observeValidity() {
+        return validity;
+    }
+
+    /**
+     * If you plan to extend this method, please consider leaving this
+     * implementation as is and use a reactive/observable style by
+     * overriding {@link #observePropensityContribution()}.
+     *
+     * @return this condition's propensity contribution.
+     */
+    @Override
+    public double getPropensityContribution() {
+        return observePropensityContribution().getCurrent();
+    }
+
+    /**
+     * If you plan to override this method, make sure to free up additional
+     * observables in {@link #dispose()}.
+     */
+    @Override
+    public Observable<Double> observePropensityContribution() {
+        return propensity;
+    }
+
+    /**
+     * Override this method if a custom implementation for validity or propensity
+     * contribution are provided. It is always advised to call the super method
+     * alongside the custom implementation to avoid possible leaks.
+     */
+    @Override
+    public void dispose() {
+        this.validity.dispose();
+        this.propensity.dispose();
+        this.dependencies.dispose();
+    }
+
     /**
      * {@inheritDoc}
      *
-     *  <p>
+     * <p>
      * How to override: create a new action of your concrete subtype.
      */
     @Override
@@ -83,6 +170,24 @@ public Condition<T> cloneCondition(final Node<T> newNode, final Reaction<T> newR
         throw new UnsupportedOperationException(getClass().getSimpleName() + " has no support for cloning.");
     }
 
+    /**
+     * To be used by inheritors when initializing.
+     *
+     * @param newValidity the validity to set
+     */
+    protected final void setValidity(final Observable<Boolean> newValidity) {
+        this.validity = newValidity;
+    }
+
+    /**
+     * To be used by inheritors when initializing.
+     *
+     * @param newPropensity the propensity to set
+     */
+    protected final void setPropensity(final Observable<Double> newPropensity) {
+        this.propensity = newPropensity;
+    }
+
     /**
      * @return the simple class name
      */
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/ConcentrationChanged.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/ConcentrationChanged.java
index 135bdc4deb..a904744895 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/ConcentrationChanged.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/ConcentrationChanged.java
@@ -44,6 +44,21 @@ public ConcentrationChanged(@Nonnull final Node<T> node, @Nonnull final Molecule
         previous = Optional.fromNullable(node.getConcentration(target));
         hasFlipped = false;
         declareDependencyOn(target);
+
+        addObservableDependency(node.observeConcentration(target));
+
+        setValidity(node.observeConcentration(target).map(it -> {
+            if (!hasFlipped) {
+                final var maybeValue = Optional.fromNullable(it.getOrNull());
+                if (!maybeValue.equals(previous)) {
+                    hasFlipped = true;
+                    previous = maybeValue;
+                }
+            }
+            return hasFlipped;
+        }));
+
+        setPropensity(observeValidity().map(valid -> valid ? 1d : 0d));
     }
 
     @Override
@@ -56,36 +71,11 @@ public Context getContext() {
         return Context.LOCAL;
     }
 
-    @Override
-    public double getPropensityContribution() {
-        return isValid(true) ? 1 : 0;
-    }
-
     @Override
     public boolean isValid() {
-        return isValid(false);
-    }
-
-    private boolean isValid(final boolean internal) {
-        /*
-         * If the call is internal, the condition may switch to true. Otherwise,
-         * it will return the previous value and switch to false
-         */
-        if (internal) {
-            if (!hasFlipped) {
-                @Nonnull
-                final Optional<T> curVal = Optional.fromNullable(getNode().getConcentration(target));
-                if (!curVal.equals(previous)) {
-                    hasFlipped = true;
-                    previous = curVal;
-                }
-            }
-        } else {
-            final boolean flip = hasFlipped;
-            hasFlipped = false;
-            return flip;
-        }
-        return hasFlipped;
+        final boolean flip = hasFlipped;
+        hasFlipped = false;
+        return flip;
     }
 
     @Override
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/MoleculeHasConcentration.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/MoleculeHasConcentration.java
index 70ea43b954..69a3306d6f 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/MoleculeHasConcentration.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/conditions/MoleculeHasConcentration.java
@@ -43,6 +43,9 @@ public MoleculeHasConcentration(final Node<T> node, final Molecule molecule, fin
         this.mol = Objects.requireNonNull(molecule);
         this.value = Objects.requireNonNull(value);
         declareDependencyOn(this.mol);
+        addObservableDependency(node.observeConcentration(molecule));
+        setValidity(node.observeConcentration(molecule).map(opt -> opt.fold(() -> false, value::equals)));
+        setPropensity(observeValidity().map(valid -> valid ? 1d : 2d));
     }
 
     @Override
@@ -55,16 +58,6 @@ public Context getContext() {
         return Context.LOCAL;
     }
 
-    @Override
-    public double getPropensityContribution() {
-        return isValid() ? 1 : 0;
-    }
-
-    @Override
-    public boolean isValid() {
-        return value.equals(getNode().getConcentration(mol));
-    }
-
     @Override
     public String toString() {
         return mol + "=" + value + "?[" + isValid() + "]";
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/AdaptiveRange.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/AdaptiveRange.java
index 33ca195dbe..6c1c2e9c80 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/AdaptiveRange.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/AdaptiveRange.java
@@ -16,7 +16,6 @@
 import it.unibo.alchemist.model.Node;
 import it.unibo.alchemist.model.Position;
 import it.unibo.alchemist.model.neighborhoods.Neighborhoods;
-import org.danilopianini.util.ListSet;
 
 import java.io.Serial;
 import java.util.stream.Collectors;
@@ -180,7 +179,7 @@ public final Neighborhood<T> computeNeighborhood(final Node<T> center, final Env
             ranges.put(center.getId(), getRange());
         }
         final double curRange = ranges.get(center.getId());
-        final ListSet<Node<T>> potentialNeighs = environment.getNodesWithinRange(center, curRange);
+        final var potentialNeighs = environment.getNodesWithinRange(center, curRange);
         final Neighborhood<T> neigh = Neighborhoods.make(environment, center, potentialNeighs.stream()
                 .filter(neighbor -> !conditionForRemoval(environment, center, neighbor, curRange, ranges.get(neighbor.getId())))
                 .collect(Collectors.toList()));
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ClosestN.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ClosestN.java
index 7b5949a9d7..529f484e02 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ClosestN.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ClosestN.java
@@ -166,7 +166,7 @@ private Stream<Node<T>> closestN(final Node<T> center, final Environment<T, ?> e
      * @param range the communication range
      * @return the set of nodes within the communication range
      */
-    protected final Set<Node<T>> nodesInRange(
+    protected final Set<? extends Node<T>> nodesInRange(
             final Environment<T, ?> environment,
             final Node<T> node, final double range
     ) {
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
index 7e598a0a65..1875c3c903 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
@@ -9,6 +9,7 @@
 
 package it.unibo.alchemist.model.reactions;
 
+import arrow.core.Option;
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import it.unibo.alchemist.model.Action;
 import it.unibo.alchemist.model.Actionable;
@@ -21,12 +22,19 @@
 import it.unibo.alchemist.model.Reaction;
 import it.unibo.alchemist.model.Time;
 import it.unibo.alchemist.model.TimeDistribution;
+import it.unibo.alchemist.model.observation.Disposable;
+import it.unibo.alchemist.model.observation.EventObservable;
+import it.unibo.alchemist.model.observation.MutableObservable;
+import it.unibo.alchemist.model.observation.Observable;
+import it.unibo.alchemist.model.observation.ObservableExtensions;
+import kotlin.Unit;
 import org.danilopianini.util.ArrayListSet;
 import org.danilopianini.util.Hashes;
 import org.danilopianini.util.ImmutableListSet;
 import org.danilopianini.util.LinkedListSet;
 import org.danilopianini.util.ListSet;
 import org.danilopianini.util.ListSets;
+import org.jetbrains.annotations.NotNull;
 
 import javax.annotation.Nonnull;
 import java.io.Serial;
@@ -38,6 +46,9 @@
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
+import static arrow.core.OptionKt.getOrElse;
+import static arrow.core.OptionKt.none;
+
 /**
  * The type which describes the concentration of a molecule.
  * This class offers a partial implementation of Reaction. In particular, it
@@ -45,7 +56,7 @@
  *
  * @param <T> concentration type
  */
-public abstract class AbstractReaction<T> implements Reaction<T> {
+public abstract class AbstractReaction<T> implements Reaction<T>, Disposable {
 
     /**
      * How bigger should be the StringBuffer with respect to the previous
@@ -58,6 +69,7 @@ public abstract class AbstractReaction<T> implements Reaction<T> {
     private final int hash;
     private List<? extends Action<T>> actions = new ArrayList<>(0);
     private List<? extends Condition<T>> conditions = new ArrayList<>(0);
+
     private Context incontext = Context.LOCAL;
     private Context outcontext = Context.LOCAL;
     private ListSet<Dependency> outbound = new LinkedListSet<>();
@@ -66,13 +78,16 @@ public abstract class AbstractReaction<T> implements Reaction<T> {
     private final TimeDistribution<T> timeDistribution;
     private final Node<T> node;
 
+    private final EventObservable rescheduleRequest = new EventObservable();
+    private Observable<Boolean> validity = MutableObservable.Companion.observe(true);
+    private final List<Observable<?>> subscriptions = new ArrayList<>();
+    private Option<Boolean> canExecute = none();
+
     /**
      * Builds a new reaction, starting at time t.
      *
-     * @param node
-     *            the node this reaction belongs to
-     * @param timeDistribution
-     *            the time distribution this reaction should follow
+     * @param node             the node this reaction belongs to
+     * @param timeDistribution the time distribution this reaction should follow
      */
     @SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "This is intentional")
     public AbstractReaction(final Node<T> node, final TimeDistribution<T> timeDistribution) {
@@ -84,8 +99,7 @@ public AbstractReaction(final Node<T> node, final TimeDistribution<T> timeDistri
     /**
      * Allows subclasses to add influenced molecules.
      *
-     * @param m
-     *            the influenced molecule
+     * @param m the influenced molecule
      */
     protected final void addOutboundDependency(final Dependency m) {
         outbound.add(m);
@@ -94,8 +108,7 @@ protected final void addOutboundDependency(final Dependency m) {
     /**
      * Allows subclasses to add influencing molecules.
      *
-     * @param m
-     *            the molecule to add
+     * @param m the molecule to add
      */
     protected final void addInboundDependency(final Dependency m) {
         inbound.add(m);
@@ -108,14 +121,16 @@ protected final void addInboundDependency(final Dependency m) {
      */
     @Override
     public boolean canExecute() {
-        if (conditions == null) {
-            return true;
+        final var current = canExecute.getOrNull();
+        if (current != null) {
+            return current;
         }
-        int i = 0;
-        while (i < conditions.size() && conditions.get(i).isValid()) {
-            i++;
-        }
-        return i == conditions.size();
+        return conditions.stream().allMatch(Condition::isValid);
+    }
+
+    @Override
+    public final @NotNull Observable<Boolean> observeCanExecute() {
+        return validity;
     }
 
     @Override
@@ -188,6 +203,11 @@ public final Context getOutputContext() {
         return outcontext;
     }
 
+    @Override
+    public final @NotNull Observable<Unit> getRescheduleRequest() {
+        return rescheduleRequest;
+    }
+
     /**
      * @return a {@link String} representation of the rate
      */
@@ -221,19 +241,48 @@ public final int hashCode() {
         return hash;
     }
 
+    /**
+     * This method is called when the environment has completed its
+     * initialization. Can be used by this reaction to compute its next
+     * execution time - in case such computation requires an inspection of the
+     * environment.
+     * <br/>
+     * <b>NOTE</b>: this method ensures that the observable dependencies
+     * (i.e. observable conditions) are properly initialized with
+     * {@link #initializeObservableConditions()}.
+     * Subclasses should override {@link #onInitializationComplete(Time, Environment)}
+     * to add custom initialization logic.
+     *
+     * @param atTime      the time at which the initialization of this reaction was
+     *                    accomplished
+     * @param environment the environment
+     */
     @Override
-    public void initializationComplete(@Nonnull final Time atTime, @Nonnull final Environment<T, ?> environment) { }
+    public final void initializationComplete(@Nonnull final Time atTime, @Nonnull final Environment<T, ?> environment) {
+        initializeObservableConditions();
+        onInitializationComplete(atTime, environment);
+    }
+
+    /**
+     * This method is called by {@link #initializationComplete(Time, Environment)}
+     * after the observable dependencies have been initialized.
+     * Subclasses can override this to perform custom initialization (e.g. initial update).
+     *
+     * @param atTime      the time at which the initialization of this reaction was
+     *                    accomplished
+     * @param environment the environment
+     */
+    protected void onInitializationComplete(@Nonnull final Time atTime, @Nonnull final Environment<T, ?> environment) {
+        // Empty by default
+    }
 
     /**
      * This method provides the facility to clone reactions.
      * Given a constructor in form of a {@link Supplier}, it populates the actions and conditions with
      * cloned version of the ones registered in this reaction.
      *
-     * @param builder
-     *            the supplier
-     *
-     * @param <R>
-     *            The reaction type
+     * @param builder the supplier
+     * @param <R>     The reaction type
      * @return the populated cloned reaction
      */
     protected <R extends Reaction<T>> R makeClone(final Supplier<R> builder) {
@@ -298,11 +347,56 @@ public void setConditions(@Nonnull final List<? extends Condition<T>> conditions
         inbound = computeDependencies(conditions.stream().map(Condition::getInboundDependencies).flatMap(List::stream));
     }
 
+    /**
+     * Call this method for handling the reactive nature of this reaction's validity, and this
+     * reaction reschedules requests, binding this reaction to its conditions' validity and
+     * on condition's inbound dependencies respectively.
+     * <br/>
+     * Note that this method must be called after the initialization (i.e. to be called in
+     * {@link #initializationComplete(Time, Environment)}) because observers' callbacks could
+     * trigger some environment query that may fail in the set-up phase.
+     */
+    protected final void initializeObservableConditions() {
+        if (!subscriptions.isEmpty()) {
+            subscriptions.forEach(s -> s.stopWatching(this));
+            subscriptions.clear();
+        }
+
+        validity.dispose();
+
+        conditions.forEach(condition -> {
+            final var merged = ObservableExtensions.ObservableSetExtensions.mergeObservables(
+                condition.observeInboundDependencies()
+            );
+            merged.onChange(this, it -> {
+                rescheduleRequest.emit();
+                return null;
+            });
+            subscriptions.add(merged);
+        });
+
+        if (!conditions.isEmpty()) {
+            validity = ObservableExtensions.INSTANCE.combineLatest(
+                conditions.stream().map(Condition::observeValidity).toList(),
+                it -> it.stream().allMatch(b -> b)
+            ).map(it -> getOrElse(it, () -> true));
+
+            // need at least one observer to track validity updates
+            validity.onChange(this, it -> {
+                canExecute = Option.fromNullable(it);
+                return null;
+            });
+
+            subscriptions.add(validity);
+        }
+
+        rescheduleRequest.emit();
+    }
+
     /**
      * Used by subclasses to set their input context.
      *
-     * @param c
-     *            the new input context
+     * @param c the new input context
      */
     protected final void setInputContext(final Context c) {
         incontext = c;
@@ -311,8 +405,7 @@ protected final void setInputContext(final Context c) {
     /**
      * Used by subclasses to set their output context.
      *
-     * @param c
-     *            the new input context
+     * @param c the new input context
      */
     protected final void setOutputContext(final Context c) {
         outcontext = c;
@@ -320,7 +413,7 @@ protected final void setOutputContext(final Context c) {
 
     /**
      * @return the default implementation returns a String in the form
-     *     className@timeScheduled[Conditions]-rate-&gt;[Actions]
+     *         className@timeScheduled[Conditions]-rate-&gt;[Actions]
      */
     @Override
     public String toString() {
@@ -348,23 +441,35 @@ public final void update(
         timeDistribution.update(currentTime, hasBeenExecuted, getRate(), environment);
     }
 
+    /**
+     * Disposes all resources held by this reaction if removed and not used any more. If plan to extend
+     * this method, please make sure to call the base implementation to free up resources for this reaction's
+     * subscriptions (input dependencies changes and condition changes).
+     * Ideally, through this method you should clear up all the references that would become dangling if
+     * the reference to this reaction is lost during program execution resulting in a memory leak.
+     */
+    @Override
+    public void dispose() {
+        subscriptions.forEach(it -> it.stopWatching(this));
+        conditions.forEach(Disposable::dispose);
+        conditions.clear();
+        subscriptions.clear();
+    }
+
     /**
      * This method gets called as soon as
      * {@link #update(Time, boolean, Environment)} is called. It is useful to
      * update the internal status of the reaction.
      *
-     * @param currentTime
-     *            the current simulation time
-     * @param hasBeenExecuted
-     *            true if this reaction has just been executed, false if the
-     *            update has been triggered due to a dependency
-     * @param environment
-     *            the current environment
+     * @param currentTime     the current simulation time
+     * @param hasBeenExecuted true if this reaction has just been executed, false if the
+     *                        update has been triggered due to a dependency
+     * @param environment     the current environment
      */
     protected abstract void updateInternalStatus(
-            Time currentTime,
-            boolean hasBeenExecuted,
-            Environment<T, ?> environment
+        Time currentTime,
+        boolean hasBeenExecuted,
+        Environment<T, ?> environment
     );
 
     @Nonnull
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/ChemicalReaction.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/ChemicalReaction.java
index 2208b4cb8c..82b32b42eb 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/ChemicalReaction.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/ChemicalReaction.java
@@ -47,7 +47,7 @@ public ChemicalReaction<T> cloneOnNewNode(@Nonnull final Node<T> node, @Nonnull
     }
 
     @Override
-    public final void initializationComplete(@Nonnull final Time atTime, @Nonnull final Environment<T, ?> environment) {
+    protected final void onInitializationComplete(@Nonnull final Time atTime, @Nonnull final Environment<T, ?> environment) {
         update(atTime, true, environment);
     }
 
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/AbstractNonPropensityContributingCondition.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/AbstractNonPropensityContributingCondition.kt
index 402a6186d9..8f27e6fd92 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/AbstractNonPropensityContributingCondition.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/AbstractNonPropensityContributingCondition.kt
@@ -17,5 +17,7 @@ import it.unibo.alchemist.model.Node
  * or with 0.0 in case it cannot.
  */
 abstract class AbstractNonPropensityContributingCondition<T>(node: Node<T>) : AbstractCondition<T>(node) {
-    final override fun getPropensityContribution(): Double = if (isValid) 1.0 else 0.0
+    init {
+        setPropensity(observeValidity().map { if (it) 1.0 else 0.0 })
+    }
 }
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/ContainsMolecule.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/ContainsMolecule.kt
index fa4b3a489d..62f87e8ea4 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/ContainsMolecule.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/ContainsMolecule.kt
@@ -16,9 +16,12 @@ import it.unibo.alchemist.model.Node
 /**
  * The condition is valid if the node contains the molecule.
  */
-class ContainsMolecule<T>(node: Node<T>, private val molecule: Molecule) :
-    AbstractNonPropensityContributingCondition<T>(node) {
-    override fun getContext() = Context.LOCAL
+class ContainsMolecule<T>(node: Node<T>, molecule: Molecule) : AbstractNonPropensityContributingCondition<T>(node) {
+
+    init {
+        addObservableDependency(node.observeContains(molecule))
+        setValidity(node.observeContains(molecule))
+    }
 
-    override fun isValid() = node.contains(molecule)
+    override fun getContext() = Context.LOCAL
 }
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NeighborHasConcentration.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NeighborHasConcentration.kt
new file mode 100644
index 0000000000..fef40f5e25
--- /dev/null
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NeighborHasConcentration.kt
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.conditions
+
+import arrow.core.getOrElse
+import it.unibo.alchemist.model.Condition
+import it.unibo.alchemist.model.Context
+import it.unibo.alchemist.model.Environment
+import it.unibo.alchemist.model.Molecule
+import it.unibo.alchemist.model.Node
+import it.unibo.alchemist.model.Reaction
+import it.unibo.alchemist.model.observation.ObservableExtensions.combineLatest
+import it.unibo.alchemist.model.observation.ObservableExtensions.switchMap
+
+/**
+ * A condition that evaluates whether at least one neighbor of a node has the specified [concentration]
+ * of a given [molecule][target].
+ *
+ * @param node the node for which the condition is being evaluated.
+ * @param environment the environment containing the node and its neighborhood.
+ * @param target the molecule to check in the neighborhood
+ * @param concentration the target concentration of the molecule to be checked in the neighborhood
+ * @param T the type of concentration
+ */
+class NeighborHasConcentration<T>(
+    node: Node<T>,
+    val environment: Environment<T, *>,
+    val target: Molecule,
+    val concentration: T,
+) : AbstractCondition<T>(node) {
+
+    init {
+        setValidity(
+            environment.observeNeighborhood(node).switchMap { neighborhood ->
+                neighborhood.neighbors.map { it.observeConcentration(target) }
+                    .combineLatest { neighborsConcentrations ->
+                        neighborsConcentrations.any { it.isSome { nConc -> nConc == concentration } }
+                    }.map { it.getOrElse { false } }
+            },
+        )
+    }
+
+    override fun getContext(): Context = Context.NEIGHBORHOOD
+
+    override fun cloneCondition(newNode: Node<T>, newReaction: Reaction<T>): Condition<T> =
+        NeighborHasConcentration(newNode, environment, target, concentration)
+}
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NoOtherReactionCanExecute.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NoOtherReactionCanExecute.kt
index 1612cb72b3..9a9760370b 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NoOtherReactionCanExecute.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NoOtherReactionCanExecute.kt
@@ -9,9 +9,11 @@
 
 package it.unibo.alchemist.model.conditions
 
+import arrow.core.getOrElse
 import it.unibo.alchemist.model.Context
 import it.unibo.alchemist.model.Node
 import it.unibo.alchemist.model.Reaction
+import it.unibo.alchemist.model.observation.ObservableExtensions.combineLatest
 
 /**
  * The condition is valid if all the other reactions having at least one condition can not execute.
@@ -31,16 +33,19 @@ class NoOtherReactionCanExecute<T>(node: Node<T>, private val myReaction: Reacti
             "Violation of the $className contract. Only a single $className per node can get built. " +
                 "Double creation at node $node, reaction $myReaction"
         }
+
+        setValidity(
+            node.reactions
+                .filterNot { it == myReaction }
+                .filter { it.conditions.isNotEmpty() }
+                .map { it.observeCanExecute() }
+                .combineLatest { reactionsCanExecute -> reactionsCanExecute.none { it } }
+                .map { it.getOrElse { true } },
+        )
     }
 
     override fun cloneCondition(newNode: Node<T>, newReaction: Reaction<T>) =
         NoOtherReactionCanExecute(newNode, myReaction)
 
     override fun getContext() = Context.LOCAL
-
-    override fun isValid() = node.reactions
-        .asSequence()
-        .filterNot { it == myReaction }
-        .filter { it.conditions.isNotEmpty() }
-        .none { it.canExecute() }
 }
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
index ea1f7da744..d8ea597236 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
@@ -11,6 +11,7 @@ package it.unibo.alchemist.model.environments
 
 import com.github.benmanes.caffeine.cache.Caffeine
 import com.github.benmanes.caffeine.cache.LoadingCache
+import gnu.trove.map.hash.TDoubleObjectHashMap
 import gnu.trove.map.hash.TIntObjectHashMap
 import gnu.trove.set.hash.TIntHashSet
 import it.unibo.alchemist.core.Simulation
@@ -26,6 +27,11 @@ import it.unibo.alchemist.model.Position
 import it.unibo.alchemist.model.SupportedIncarnations
 import it.unibo.alchemist.model.TerminationPredicate
 import it.unibo.alchemist.model.linkingrules.NoLinks
+import it.unibo.alchemist.model.observation.Observable
+import it.unibo.alchemist.model.observation.ObservableMutableMap
+import it.unibo.alchemist.model.observation.ObservableMutableSet
+import it.unibo.alchemist.model.observation.ObservableMutableSet.Companion.toObservableSet
+import it.unibo.alchemist.model.observation.ObservableSet
 import java.io.ObjectInputStream
 import java.io.ObjectOutputStream
 import java.io.Serial
@@ -56,8 +62,15 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
     private val _globalReactions = ArrayListSet<GlobalReaction<T>>()
     final override var layers: Map<Molecule, Layer<T, P>> = LinkedHashMap()
         private set
+
+    @Transient
+    private val observableNeighCache = ObservableMutableMap<Int, Neighborhood<T>>()
     private val neighCache = TIntObjectHashMap<Neighborhood<T>>()
+
+    @Transient
+    private val observableNodeToPos = ObservableMutableMap<Int, P>()
     private val nodeToPos = TIntObjectHashMap<P>()
+
     private val spatialIndex: SpatialIndex<Node<T>> = internalIndex
 
 //    override val layers: Map<Molecule, Layer<T, P>> get() = _layers
@@ -67,8 +80,20 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
 
     override val nodes: ListSet<Node<T>> = ListSets.unmodifiableListSet(_nodes)
 
+    @Transient
+    override val observableNodes: ObservableMutableSet<Node<T>> = _nodes.toList().toObservableSet()
+
     final override val nodeCount: Int get() = nodes.size
 
+    @Transient
+    override val observeNodeCount: Observable<Int> = observableNodes.observableSize
+
+    private val regionObservers = ArrayList<RegionObserver>()
+
+    private val regionNodeCenteredIndex = TIntObjectHashMap<TDoubleObjectHashMap<RegionObserver>>()
+
+    private val regionPositionCenteredIndex = HashMap<P, TDoubleObjectHashMap<RegionObserver>>()
+
     final override var linkingRule: LinkingRule<T, P> = NoLinks()
 
     @Transient
@@ -125,6 +150,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
             val actualPosition = computeActualInsertionPosition(node, position)
             setPosition(node, actualPosition)
             require(_nodes.add(node)) { "Node with id ${node.id} was already existing in this environment." }
+            observableNodes.add(node)
             spatialIndex.insert(node, *actualPosition.coordinates)
             updateNeighborhood(node, true)
             ifEngineAvailable { it.nodeAdded(node) }
@@ -178,6 +204,55 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         return validCache[center to range]
     }
 
+    private fun observeAllNodesInRange(
+        centerProvider: () -> P,
+        range: Double,
+        node: Node<T>? = null,
+    ): ObservableSet<Node<T>> {
+        val cached = if (node != null) {
+            regionNodeCenteredIndex[node.id]?.get(range)
+        } else {
+            regionPositionCenteredIndex[centerProvider()]?.get(range)
+        }
+
+        if (cached != null) {
+            return cached.visibleNodes
+        }
+
+        val actualCenter = centerProvider()
+        val initialNodes = getAllNodesInRange(centerProvider(), range).toObservableSet()
+
+        if (node != null) {
+            check(initialNodes.remove(node)) {
+                "Either the provided range ($range) is too small for queries to work without precision loss, " +
+                    "or the environment is in an inconsistent state. Node $node at ${centerProvider()} was the " +
+                    "query center, but within range $range, only nodes $initialNodes were found."
+            }
+        }
+
+        val region = RegionObserver(
+            centerId = node?.id,
+            centerProvider = centerProvider,
+            radius = range,
+            visibleNodes = initialNodes,
+        ).apply { regionObservers.add(this) }
+
+        if (node != null) {
+            var radiusMap = regionNodeCenteredIndex[node.id]
+            if (radiusMap == null) {
+                radiusMap = TDoubleObjectHashMap()
+                regionNodeCenteredIndex.put(node.id, radiusMap)
+            }
+            radiusMap.put(range, region)
+        } else {
+            regionPositionCenteredIndex
+                .computeIfAbsent(actualCenter) { TDoubleObjectHashMap() }
+                .put(range, region)
+        }
+
+        return initialNodes
+    }
+
     override fun getDistanceBetweenNodes(n1: Node<T>, n2: Node<T>): Double = getPosition(n1).distanceTo(getPosition(n2))
 
     override fun getLayer(molecule: Molecule): Layer<T, P>? = layers[molecule]
@@ -193,6 +268,18 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         return result
     }
 
+    override fun observeNeighborhood(node: Node<T>): Observable<Neighborhood<T>> =
+        observableNeighCache[node.id].map { maybeNeighborhood ->
+            val neighborhood = maybeNeighborhood.getOrNull()
+            requireNotNull(neighborhood) {
+                check(node !in observableNodes) {
+                    "The environment state is inconsistent. $node is among the nodes, but has no position."
+                }
+                "$node is not part of the environment."
+            }
+            neighborhood
+        }
+
     override fun getNodeByID(id: Int): Node<T> = nodes.first { n: Node<T> -> n.id == id }
 
     override fun getNodesWithinRange(node: Node<T>, range: Double): ListSet<Node<T>> {
@@ -213,6 +300,12 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         return ImmutableListSet.copyOf(getAllNodesInRange(position, range))
     }
 
+    override fun observeNodesWithinRange(node: Node<T>, range: Double): ObservableSet<Node<T>> =
+        observeAllNodesInRange({ getPosition(node) }, range, node)
+
+    override fun observeNodesWithinRange(position: P, range: Double): ObservableSet<Node<T>> =
+        observeAllNodesInRange({ position }, range)
+
     override fun getPosition(node: Node<T>): P = requireNotNull(nodeToPos[node.id]) {
         check(!nodes.contains(node)) {
             "Node $node is registered in the environment but has no position. " +
@@ -222,6 +315,19 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         "Node $node: ${node.javaClass.simpleName} does not exist in the environment."
     }
 
+    override fun observePosition(node: Node<T>): Observable<P> = observableNodeToPos[node.id].map { maybePosition ->
+        val position = maybePosition.getOrNull()
+        requireNotNull(position) {
+            check(!nodes.contains(node)) {
+                "Node $node is registered in the environment but has no position. " +
+                    "This could be a bug in Alchemist. Please open an issue at: " +
+                    "https://github.com/AlchemistSimulator/Alchemist/issues/new/choose"
+            }
+            "Node $node: ${node.javaClass.simpleName} does not exist in the environment."
+        }
+        position
+    }
+
     /**
      * Override this property if units measuring distance do not match with units used
      * for coordinates. For instance, if your space is non-Euclidean, or if you are
@@ -300,6 +406,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
     private fun recursiveOperation(origin: Node<T>): Sequence<Operation<T>> {
         val newNeighborhood = linkingRule.computeNeighborhood(Objects.requireNonNull(origin), this)
         val oldNeighborhood: Neighborhood<T>? = neighCache.put(origin.id, newNeighborhood)
+        observableNeighCache.put(origin.id, newNeighborhood)
         return toQueue(origin, oldNeighborhood, newNeighborhood)
     }
 
@@ -314,16 +421,27 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         }
         val newNeighborhood = linkingRule.computeNeighborhood(destination, this)
         val oldNeighborhood = neighCache.put(destination.id, newNeighborhood)
+        observableNeighCache.put(destination.id, newNeighborhood)
         return toQueue(destination, oldNeighborhood, newNeighborhood)
     }
 
     override fun removeNode(node: Node<T>) {
         invalidateCache()
         _nodes.remove(requireNotNull(node) { "Node cannot be null." })
+        observableNodes.remove(node)
         val pos = requireNotNull(nodeToPos.remove(node.id)) { "Node position cannot be null." }
+        observableNodeToPos.remove(node.id)
         spatialIndex.remove(node, *pos.coordinates)
         val neigh = neighCache.remove(node.id)
-        neigh.forEach { neighCache.put(it.id, neighCache.remove(it.id).remove(node)) }
+        observableNeighCache.remove(node.id)
+        neigh.forEach {
+            with(neighCache.remove(it.id).remove(node)) {
+                neighCache.put(it.id, this)
+                observableNeighCache.remove(it.id)
+                observableNeighCache.put(it.id, this)
+            }
+        }
+        updateRegionObservers(node, null, null)
         ifEngineAvailable { it.nodeRemoved(node, neigh) }
         nodeRemoved(node, neigh)
     }
@@ -346,10 +464,39 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         require(pos == null || spatialIndex.move(n, pos.coordinates, p.coordinates)) {
             "Tried to move a node not previously present in the environment:\nNode: $n\nRequested position: $p"
         }
+        observableNodeToPos[n.id] = p
+        updateRegionObservers(n, p, pos)
     }
 
     override fun spliterator(): Spliterator<Node<T>> = nodes.spliterator()
 
+    private fun updateRegionObservers(node: Node<T>, newPosition: P?, oldPosition: P?) {
+        if (regionObservers.isNotEmpty()) {
+            regionObservers.forEach { region ->
+                when {
+                    newPosition == null -> { // removal
+                        if (node in region.visibleNodes) region.visibleNodes.remove(node)
+                        regionNodeCenteredIndex.remove(node.id)?.forEachValue {
+                            regionObservers.remove(it)
+                            true
+                        }
+                    }
+                    else -> { // new node added or moved
+                        val center = region.centerProvider()
+
+                        val wasInside = oldPosition?.distanceTo(center)?.let { it <= region.radius } ?: false
+                        val isInside = newPosition.distanceTo(center) <= region.radius
+
+                        when {
+                            wasInside && !isInside -> region.visibleNodes.remove(node)
+                            !wasInside && isInside -> region.visibleNodes.add(node)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     private fun toQueue(
         center: Node<T>,
         oldNeighborhood: Neighborhood<T>?,
@@ -373,6 +520,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         if (linkingRule.isLocallyConsistent()) {
             val newNeighborhood = linkingRule.computeNeighborhood(node, this)
             val oldNeighborhood: Neighborhood<T>? = neighCache.put(node.id, newNeighborhood)
+            observableNeighCache.put(node.id, newNeighborhood)
             oldNeighborhood?.let {
                 it
                     .getNeighbors()
@@ -382,7 +530,10 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
                     .filter { neigh -> neigh.contains(node) }
                     .forEach { neighborhoodToChange ->
                         val formerNeighbor = neighborhoodToChange.getCenter()
-                        neighCache.put(formerNeighbor.id, neighborhoodToChange.remove(node))
+                        with(neighborhoodToChange.remove(node)) {
+                            neighCache.put(formerNeighbor.id, this)
+                            observableNeighCache.put(formerNeighbor.id, this)
+                        }
                         if (!isNewNode) {
                             ifEngineAvailable { it.neighborRemoved(node, formerNeighbor) }
                         }
@@ -391,7 +542,10 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
             val newNeighbors = newNeighborhood.neighbors
             val oldNeighbors: Set<Node<T>>? = oldNeighborhood?.neighbors
             (newNeighbors - oldNeighbors.orEmpty()).forEach { newNeighbor ->
-                neighCache.put(newNeighbor.id, neighCache[newNeighbor.id].add(node))
+                with(neighCache[newNeighbor.id].add(node)) {
+                    neighCache.put(newNeighbor.id, this)
+                    observableNeighCache.put(newNeighbor.id, this)
+                }
                 if (!isNewNode) {
                     ifEngineAvailable { it.neighborAdded(node, newNeighbor) }
                 }
@@ -413,6 +567,13 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         out.writeObject(incarnation.javaClass.getSimpleName())
     }
 
+    private inner class RegionObserver(
+        val centerId: Int? = null,
+        val centerProvider: () -> P,
+        val radius: Double,
+        val visibleNodes: ObservableMutableSet<Node<T>>,
+    )
+
     private data class Operation<T>(val origin: Node<T>, val destination: Node<T>, val isAdd: Boolean) {
         override fun toString(): String = origin.toString() + (if (isAdd) " discovered " else " lost ") + destination
     }
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
index f4b8715ebc..ea6bbddb91 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
@@ -8,6 +8,8 @@
  */
 package it.unibo.alchemist.model.nodes
 
+import arrow.core.Option
+import arrow.core.getOrElse
 import com.google.common.collect.MapMaker
 import it.unibo.alchemist.model.Environment
 import it.unibo.alchemist.model.Molecule
@@ -15,6 +17,8 @@ import it.unibo.alchemist.model.Node
 import it.unibo.alchemist.model.NodeProperty
 import it.unibo.alchemist.model.Reaction
 import it.unibo.alchemist.model.Time
+import it.unibo.alchemist.model.observation.Observable
+import it.unibo.alchemist.model.observation.ObservableMutableMap
 import java.util.Collections
 import java.util.Spliterator
 import java.util.concurrent.Semaphore
@@ -40,10 +44,14 @@ constructor(
     /**
      * The node's molecules.
      */
-    val molecules: MutableMap<Molecule, T> = LinkedHashMap(),
+    molecules: MutableMap<Molecule, T> = LinkedHashMap(),
     final override val properties: MutableList<NodeProperty<T>> = ArrayList(),
 ) : Node<T> {
 
+    override val observableContents: ObservableMutableMap<Molecule, T> = ObservableMutableMap(molecules)
+
+    override val observeMoleculeCount: Observable<Int> = observableContents.map { it.size }
+
     final override fun addReaction(reactionToAdd: Reaction<T>) {
         reactions.add(reactionToAdd)
     }
@@ -56,7 +64,11 @@ constructor(
 
     final override fun compareTo(@Nonnull other: Node<T>): Int = id.compareTo(other.id)
 
-    override fun contains(molecule: Molecule): Boolean = molecules.containsKey(molecule)
+    override fun contains(molecule: Molecule): Boolean = observeContains(molecule).current
+
+    override fun observeContains(molecule: Molecule): Observable<Boolean> = observableContents.map {
+        it.contains(molecule)
+    }
 
     /**
      * @return an empty concentration
@@ -70,18 +82,22 @@ constructor(
      */
     final override fun forEach(action: Consumer<in Reaction<T>>) = reactions.forEach(action)
 
-    override fun getConcentration(molecule: Molecule): T = molecules[molecule] ?: createT()
+    override fun getConcentration(molecule: Molecule): T = observeConcentration(molecule).current.getOrElse {
+        createT()
+    }
+
+    override fun observeConcentration(molecule: Molecule): Observable<Option<T>> = observableContents[molecule]
 
-    override val contents: Map<Molecule, T> = Collections.unmodifiableMap(molecules)
+    override val contents: Map<Molecule, T> = Collections.unmodifiableMap(observableContents.current)
 
-    override val moleculeCount: Int get() = molecules.size
+    override val moleculeCount: Int get() = observeMoleculeCount.current
 
     final override fun hashCode(): Int = id // TODO: better hashing
 
     final override fun iterator(): Iterator<Reaction<T>> = reactions.iterator()
 
     final override fun removeConcentration(moleculeToRemove: Molecule) {
-        if (molecules.remove(moleculeToRemove) == null) {
+        if (observableContents.remove(moleculeToRemove) == null) {
             throw NoSuchElementException("$moleculeToRemove was not present in node $id")
         }
     }
@@ -91,7 +107,7 @@ constructor(
     }
 
     override fun setConcentration(molecule: Molecule, concentration: T) {
-        molecules[molecule] = concentration
+        observableContents[molecule] = concentration
     }
 
     final override fun addProperty(nodeProperty: NodeProperty<T>) {
@@ -110,7 +126,7 @@ constructor(
      */
     final override fun spliterator(): Spliterator<Reaction<T>> = reactions.spliterator()
 
-    override fun toString(): String = "Node$id{ properties: $properties, molecules: $molecules }"
+    override fun toString(): String = "Node$id{ properties: $properties, molecules: ${observableContents.current}}"
 
     private companion object {
         private const val serialVersionUID = 2496775909028222278L
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/AbstractNeighborCondition.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/AbstractNeighborCondition.java
index 6799a2adde..926d08cb01 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/AbstractNeighborCondition.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/AbstractNeighborCondition.java
@@ -14,9 +14,13 @@
 import it.unibo.alchemist.model.Node;
 import it.unibo.alchemist.model.Reaction;
 import it.unibo.alchemist.model.conditions.AbstractCondition;
+import it.unibo.alchemist.model.observation.Observable;
+import it.unibo.alchemist.model.observation.ObservableExtensions;
 import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
 
 import java.io.Serial;
+import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 
@@ -25,8 +29,7 @@
  * Formally, this condition is satisfied
  * if at least one neighbor satisfies the condition.
  *
- * @param <T>
- *            the concentration type.
+ * @param <T> the concentration type.
  */
 public abstract class AbstractNeighborCondition<T> extends AbstractCondition<T> {
 
@@ -36,14 +39,14 @@ public abstract class AbstractNeighborCondition<T> extends AbstractCondition<T>
     private final Environment<T, ?> environment;
 
     /**
-     * @param node
-     *            the node hosting this condition
-     * @param environment
-     *            the current environment
+     * @param node        the node hosting this condition
+     * @param environment the current environment
      */
     protected AbstractNeighborCondition(final Environment<T, ?> environment, final Node<T> node) {
         super(node);
         this.environment = environment;
+        addObservableDependency(getEnvironment().observeNeighborhood(getNode()));
+        setPropensityContributionObservable();
     }
 
     @Override
@@ -63,13 +66,11 @@ public final Context getContext() {
 
     /**
      * Override if the desired behavior differs. Default is returning the sum of the neighbor's propensities
-     *
-     * @return the sum of the neighbor's propensities
      */
-    @Override
-    public double getPropensityContribution() {
-        // the condition's propensity contribution is computed as the sum of the neighbor's propensities
-        return getValidNeighbors().values().stream().mapToDouble(it -> it).sum();
+    protected void setPropensityContributionObservable() {
+        setPropensity(observeValidNeighbors().map(nodes ->
+            nodes.values().stream().mapToDouble(it -> it).sum()
+        ));
     }
 
     /**
@@ -81,10 +82,36 @@ public double getPropensityContribution() {
      * @return a map of neighbors which satisfy the condition and their propensity
      */
     public final Map<Node<T>, Double> getValidNeighbors() {
-        return getEnvironment().getNeighborhood(getNode()).getNeighbors().stream()
-                .map(it -> new ImmutablePair<>(it, getNeighborPropensity(it)))
-                .filter(it -> it.getValue() > 0)
-                .collect(Collectors.toMap(ImmutablePair::getKey, ImmutablePair::getValue));
+        return observeValidNeighbors().getCurrent();
+    }
+
+    /**
+     * Searches in the given neighborhood which nodes satisfy the condition and
+     * returns a list of valid neighbors as an {@link Observable}. The observed map
+     * emits if:
+     * <ul>
+     *     <li>Neighbors belonging to the neighborhood of the node associated with this condition changes;</li>
+     *     <li>Some neighbor propensity (observed through {@link #observeNeighborPropensity(Node)}) changes.</li>
+     * </ul>
+     *
+     * @return an observable which emits a map of neighbors which satisfy the condition and their propensity.
+     */
+    public final Observable<Map<Node<T>, Double>> observeValidNeighbors() {
+        return ObservableExtensions.INSTANCE.switchMap(
+            getEnvironment().observeNeighborhood(getNode()),
+            neighborhood -> {
+                final List<Observable<Pair<Node<T>, Double>>> propensities = neighborhood.getNeighbors().stream()
+                    .map((Node<T> neighbor) -> observeNeighborPropensity(neighbor)
+                        .map(prop -> (Pair<Node<T>, Double>) new ImmutablePair<>(neighbor, prop))).toList();
+
+                return ObservableExtensions.INSTANCE.combineLatest(
+                    propensities,
+                    list -> list.stream()
+                        .filter(pair -> pair.getValue() > 0)
+                        .collect(Collectors.toMap(Pair::getKey, Pair::getValue))
+                ).map(it -> it.fold(Map::of, val -> val));
+            }
+        );
     }
 
     /**
@@ -95,8 +122,7 @@ public final Map<Node<T>, Double> getValidNeighbors() {
      * every neighbor and randomly choose one of them.
      *
      * @param neighbor - the neighbor whose propensity to be chosen has to be computed
-     *
-     * @return the neighbor's propensity to be chosen as the other node of the reaction
+     * @return an observable of the neighbor's propensity to be chosen as the other node of the reaction
      */
-    protected abstract double getNeighborPropensity(Node<T> neighbor);
+    protected abstract Observable<Double> observeNeighborPropensity(Node<T> neighbor);
 }
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java
index 977bb8eaa4..2f582029c9 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java
@@ -17,13 +17,12 @@
 import it.unibo.alchemist.model.Reaction;
 import it.unibo.alchemist.model.biochemistry.EnvironmentNode;
 import it.unibo.alchemist.model.biochemistry.molecules.Biomolecule;
+import it.unibo.alchemist.model.observation.Observable;
 import org.apache.commons.math3.util.CombinatoricsUtils;
 import org.apache.commons.math3.util.FastMath;
 
 import javax.annotation.Nullable;
 import java.io.Serial;
-import java.util.List;
-import java.util.stream.Collectors;
 
 /**
  * @param <P> Position type
@@ -56,28 +55,7 @@ public BiomolPresentInEnv(
     ) {
         super(node, biomolecule, concentration);
         this.environment = environment;
-    }
-
-    @Override
-    public double getPropensityContribution() {
-        final double totalQuantity = getTotalQuantity();
-        if (totalQuantity < getQuantity()) {
-            return 0;
-        }
-        return CombinatoricsUtils.binomialCoefficientDouble(
-                (int) FastMath.round(totalQuantity),
-                (int) FastMath.round(getQuantity())
-            );
-    }
-
-    /**
-     * @return a list of EnvironmentNodes near to the node where this condition is located.
-     */
-    private List<Node<Double>> getEnviromentNodesSurrounding() {
-        return environment.getNeighborhood(getNode()).getNeighbors().stream()
-                .parallel()
-                .filter(n -> n instanceof EnvironmentNode)
-                .collect(Collectors.toList());
+        setUpObservability();
     }
 
     @Override
@@ -90,29 +68,41 @@ public Context getContext() {
         return Context.NEIGHBORHOOD;
     }
 
-    @Override
-    public boolean isValid() {
-        return getTotalQuantity() >= getQuantity();
-    }
-
-    private Biomolecule getBiomolecule() {
-        return (Biomolecule) getMolecule();
+    private void setUpObservability() {
+        final Observable<Double> totalQuantity = observeTotalQuantity();
+        addObservableDependency(totalQuantity);
+        setValidity(totalQuantity.map(totalQty -> totalQty >= getQuantity()));
+        setPropensity(totalQuantity.map(totalQty -> {
+            if (totalQty < getQuantity()) {
+                return 0d;
+            }
+            return CombinatoricsUtils.binomialCoefficientDouble(
+                (int) FastMath.round(totalQty),
+                (int) FastMath.round(getQuantity())
+            );
+        }));
     }
 
-    private double getTotalQuantity() {
-        double quantityInEnvNodes = 0;
-        if (!getEnviromentNodesSurrounding().isEmpty()) {
-            quantityInEnvNodes = getEnviromentNodesSurrounding().stream()
+    private Observable<Double> observeTotalQuantity() {
+        return environment.observeNeighborhood(getNode()).mergeWith(
+            environment.observePosition(getNode()),
+            (neighborhood, position) -> {
+                final double quantityInEnvNodes = neighborhood.getNeighbors().stream()
                     .parallel()
+                    .filter(EnvironmentNode.class::isInstance)
                     .mapToDouble(n -> n.getConcentration(getBiomolecule()))
                     .sum();
-        }
-        double quantityInLayers = 0;
-        final @Nullable Layer<Double, P> layer = environment.getLayer(getBiomolecule());
-        if (layer != null) {
-            quantityInLayers = layer.getValue(environment.getPosition(getNode()));
-        }
-        return quantityInEnvNodes + quantityInLayers;
+                double quantityInLayers = 0;
+                final @Nullable Layer<Double, P> layer = environment.getLayer(getBiomolecule());
+                if (layer != null) {
+                    quantityInLayers = layer.getValue(position);
+                }
+                return quantityInEnvNodes + quantityInLayers;
+            }
+        );
     }
 
+    private Biomolecule getBiomolecule() {
+        return (Biomolecule) getMolecule();
+    }
 }
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.java
index 4a08bd95e9..7e642f9fed 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.java
@@ -15,10 +15,11 @@
 import it.unibo.alchemist.model.Reaction;
 import it.unibo.alchemist.model.biochemistry.CellProperty;
 import it.unibo.alchemist.model.biochemistry.molecules.Biomolecule;
+import it.unibo.alchemist.model.observation.MutableObservable;
+import it.unibo.alchemist.model.observation.Observable;
 import org.apache.commons.math3.util.FastMath;
 
 import java.io.Serial;
-import java.util.Optional;
 
 import static org.apache.commons.math3.util.CombinatoricsUtils.binomialCoefficientDouble;
 
@@ -34,10 +35,10 @@ public final class BiomolPresentInNeighbor extends AbstractNeighborCondition<Dou
     private final Double concentration;
 
     /**
-     * @param molecule the molecule to check
+     * @param molecule      the molecule to check
      * @param concentration the minimum concentration
-     * @param node the local node
-     * @param environment the environment
+     * @param node          the local node
+     * @param environment   the environment
      */
     public BiomolPresentInNeighbor(
         final Environment<Double, ?> environment,
@@ -49,21 +50,7 @@ public BiomolPresentInNeighbor(
         declareDependencyOn(molecule);
         this.molecule = molecule;
         this.concentration = concentration;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public boolean isValid() {
-        if (getValidNeighbors().isEmpty()) {
-            return false;
-        } else {
-            final Neighborhood<Double> neighborhood = getEnvironment().getNeighborhood(getNode());
-            return getValidNeighbors().entrySet().stream()
-                .filter(n -> n.getKey().asPropertyOrNull(CellProperty.class) != null)
-                .allMatch(n ->
-                    neighborhood.contains(n.getKey()) && n.getKey().getConcentration(molecule) >= concentration
-                );
-        }
+        setUpObservability();
     }
 
     @Override
@@ -73,14 +60,18 @@ public BiomolPresentInNeighbor cloneCondition(final Node<Double> node, final Rea
 
     @SuppressWarnings("unchecked")
     @Override
-    protected double getNeighborPropensity(final Node<Double> neighbor) {
+    protected Observable<Double> observeNeighborPropensity(final Node<Double> neighbor) {
         // the neighbor is eligible, its propensity is computed using the concentration of the biomolecule
-        return Optional.of(neighbor)
-            .filter(it -> it.asPropertyOrNull(CellProperty.class) != null)
-            .map(it -> it.getConcentration(molecule))
-            .filter(it -> it >= concentration)
-            .map(it -> binomialCoefficientDouble(it.intValue(), (int) FastMath.ceil(concentration)))
-            .orElse(0d);
+        if (neighbor.asPropertyOrNull(CellProperty.class) == null) {
+            return MutableObservable.Companion.observe(0d);
+        }
+        return neighbor.observeConcentration(molecule).map(opt -> opt.map(conc -> {
+            if (conc >= concentration) {
+                return binomialCoefficientDouble(conc.intValue(), (int) FastMath.ceil(concentration));
+            } else {
+                return 0d;
+            }
+        }).fold(() -> 0d, val -> val));
     }
 
     @Override
@@ -88,4 +79,21 @@ public String toString() {
         return molecule.toString() + " >= " + concentration + " in neighbor";
     }
 
+    @SuppressWarnings("unchecked")
+    private void setUpObservability() {
+        addObservableDependency(getNode().observeConcentration(molecule));
+        setValidity(
+            observeValidNeighbors().map(validNeighbors -> {
+                if (validNeighbors.isEmpty()) {
+                    return false;
+                }
+                final Neighborhood<Double> neighborhood = getEnvironment().getNeighborhood(getNode());
+                return validNeighbors.entrySet().stream()
+                    .filter(n -> n.getKey().asPropertyOrNull(CellProperty.class) != null)
+                    .allMatch(n ->
+                        neighborhood.contains(n.getKey()) && n.getKey().getConcentration(molecule) >= concentration
+                    );
+            })
+        );
+    }
 }
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/EnvPresent.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/EnvPresent.java
index cb763ac344..413cfff457 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/EnvPresent.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/EnvPresent.java
@@ -38,6 +38,13 @@ public final class EnvPresent extends AbstractCondition<Double> {
     public EnvPresent(final Environment<Double, ?> environment, final Node<Double> node) {
         super(node);
         this.environment = environment;
+
+        addObservableDependency(environment.observeNeighborhood(node));
+        setValidity(environment.observeNeighborhood(node).map(it ->
+            it.getNeighbors().stream().anyMatch(n -> n instanceof EnvironmentNode)
+        ));
+
+        setPropensity(observeValidity().map(it -> it ? 1d : 0d));
     }
 
     @Override
@@ -50,17 +57,6 @@ public Context getContext() {
         return Context.NEIGHBORHOOD;
     }
 
-    @Override
-    public double getPropensityContribution() {
-        return isValid() ? 1d : 0d;
-    }
-
-    @Override
-    public boolean isValid() {
-        return environment.getNeighborhood(getNode()).getNeighbors().stream()
-                .anyMatch(n -> n instanceof EnvironmentNode);
-    }
-
     @Override
     public String toString() {
         return "has environment [" + isValid() + "]";
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/GenericMoleculePresent.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/GenericMoleculePresent.java
index 3ca22d710b..cef79d9cbe 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/GenericMoleculePresent.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/GenericMoleculePresent.java
@@ -18,6 +18,8 @@
 
 import java.io.Serial;
 
+import static arrow.core.OptionKt.getOrElse;
+
 /**
  * This class implements a condition which checks if a molecule is present or
  * not.
@@ -48,6 +50,7 @@ public GenericMoleculePresent(final Node<T> n, final Molecule mol, final T quant
         molecule = mol;
         qty = quantity;
         declareDependencyOn(mol);
+        setupObservables();
     }
 
     /**
@@ -59,13 +62,32 @@ public Context getContext() {
     }
 
     /**
-     * @return true if the concentration of the molecule is higher or equal the
-     *         value.
+     * Sets up the observables that backs this condition validity and propensity contribution.
+     * The validity returns true if the concentration of the molecule is higher or equal the value.
+     * Propensity influence is computed through the binomial coefficient. See
+     * <a href="https://doi.org/10.1007/978-3-540-68894-5">
+     * Bernardo, Degano, Zavattaro - Formal Methods for Computational Systems Biology
+     * </a>.
+     *
      */
-    @Override
-    public boolean isValid() {
-        return getNode().getConcentration(molecule).doubleValue() >= qty
-                .doubleValue();
+    private void setupObservables() {
+        final var obs = getNode().observeConcentration(molecule);
+
+        addObservableDependency(obs);
+
+        setValidity(obs.map(it -> {
+            final double value = getOrElse(it, () -> 0.0).doubleValue();
+            return value >= qty.doubleValue();
+        }));
+
+        setPropensity(obs.map(it -> {
+            final int n = getOrElse(it, () -> 0).intValue();
+            final int k = qty.intValue();
+            if (k > n) {
+                return 0.0;
+            }
+            return CombinatoricsUtils.binomialCoefficientDouble(n, k);
+        }));
     }
 
     /**
@@ -84,24 +106,6 @@ public GenericMoleculePresent<T> cloneCondition(final Node<T> newNode, final Rea
         return new GenericMoleculePresent<>(newNode, molecule, qty);
     }
 
-    /**
-     * Propensity influence is computed through the binomial coefficient. See
-     * <a href="https://doi.org/10.1007/978-3-540-68894-5">
-     * Bernardo, Degano, Zavattaro - Formal Methods for Computational Systems Biology
-     * </a>.
-     *
-     * @return the propensity influence
-     */
-    @Override
-    public double getPropensityContribution() {
-        final int n = getNode().getConcentration(molecule).intValue();
-        final int k = qty.intValue();
-        if (k > n) {
-            return 0;
-        }
-        return CombinatoricsUtils.binomialCoefficientDouble(n, k);
-    }
-
     /**
      * Allows accessing the threshold.
      *
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/GenericMoleculeUnderLevel.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/GenericMoleculeUnderLevel.java
index 2fee362f89..022d64b550 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/GenericMoleculeUnderLevel.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/GenericMoleculeUnderLevel.java
@@ -15,30 +15,25 @@
 
 import java.io.Serial;
 
+import static arrow.core.OptionKt.getOrElse;
+
 /**
  * @param <T> the concentration type
  */
 public final class GenericMoleculeUnderLevel<T extends Number> extends
-        GenericMoleculePresent<T> {
+    GenericMoleculePresent<T> {
 
     @Serial
     private static final long serialVersionUID = -5646651431692309010L;
 
     /**
-     * @param mol the molecule
-     * @param n the node
+     * @param mol      the molecule
+     * @param n        the node
      * @param quantity how many molecules should be present
      */
     public GenericMoleculeUnderLevel(final Node<T> n, final Molecule mol, final T quantity) {
         super(n, mol, quantity);
-    }
-
-    /**
-     * @return true if the concentration of the molecule is lower the value.
-     */
-    @Override
-    public boolean isValid() {
-        return getNode().getConcentration(getMolecule()).doubleValue() < getQuantity().doubleValue();
+        setUpObservability();
     }
 
     @Override
@@ -47,16 +42,22 @@ public GenericMoleculeUnderLevel<T> cloneCondition(final Node<T> newNode, final
     }
 
     /**
-     * @return the propensity influence computed as max(0, T-[M]), where T is
-     *         the threshold chosen and [M] is the current concentration of the
-     *         molecule
+     * This condition validity is true if the concentration of the molecule is lower the value;
+     * the propensity influence computed as max(0, T-[M]), where T is the threshold chosen
+     * and [M] is the current concentration of the molecule.
      */
-    @Override
-    public double getPropensityContribution() {
+    private void setUpObservability() {
+        final var dep = getNode().observeConcentration(getMolecule());
         final double qty = getQuantity().doubleValue();
-        final double c = getNode().getConcentration(getMolecule())
-                .doubleValue();
-        return Math.max(0, qty - c);
-    }
 
+        addObservableDependency(dep);
+
+        setValidity(dep.map(newValue ->
+            getOrElse(newValue, () -> Double.NEGATIVE_INFINITY).doubleValue() < qty
+        ));
+
+        setPropensity(dep.map(newValue ->
+            Math.max(0, qty - getOrElse(newValue, () -> 0.0).doubleValue())
+        ));
+    }
 }
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/JunctionPresentInCell.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/JunctionPresentInCell.java
index a838056fb6..082844bc03 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/JunctionPresentInCell.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/JunctionPresentInCell.java
@@ -14,12 +14,15 @@
 import it.unibo.alchemist.model.Reaction;
 import it.unibo.alchemist.model.biochemistry.CellProperty;
 import it.unibo.alchemist.model.biochemistry.molecules.Junction;
+import it.unibo.alchemist.model.observation.MutableObservable;
+import it.unibo.alchemist.model.observation.Observable;
+import it.unibo.alchemist.model.observation.ObservableExtensions;
 
 import java.io.Serial;
-import java.util.Collections;
 import java.util.Objects;
 
 /**
+ * Condition that is valid if a specific junction is present in the cell.
  */
 public final class JunctionPresentInCell extends AbstractNeighborCondition<Double> {
 
@@ -31,25 +34,21 @@ public final class JunctionPresentInCell extends AbstractNeighborCondition<Doubl
     private final CellProperty<?> cell;
 
     /**
-     * @param junction the junction
-     * @param node the node
+     * @param junction    the junction
+     * @param node        the node
      * @param environment the environment
      */
     public JunctionPresentInCell(final Environment<Double, ?> environment, final Node<Double> node, final Junction junction) {
         super(environment, node);
         cell = node.asPropertyOrNull(CellProperty.class);
         Objects.requireNonNull(
-                cell,
-                "This Condition can be set only in node with " + CellProperty.class.getSimpleName()
+            cell,
+            "This Condition can be set only in node with " + CellProperty.class.getSimpleName()
         );
         declareDependencyOn(junction);
         this.junction = junction;
         this.environment = environment;
-    }
-
-    @Override
-    public boolean isValid() {
-        return cell.containsJunction(junction);
+        setUpObservability();
     }
 
     @Override
@@ -58,11 +57,17 @@ public JunctionPresentInCell cloneCondition(final Node<Double> newNode, final Re
     }
 
     @Override
-    protected double getNeighborPropensity(final Node<Double> neighbor) {
-        // the neighbor's propensity is computed as the number of junctions it has
-        return cell.getJunctions()
-            .getOrDefault(junction, Collections.emptyMap())
-            .getOrDefault(neighbor, 0);
+    protected Observable<Double> observeNeighborPropensity(final Node<Double> neighbor) {
+        return ObservableExtensions.INSTANCE.switchMap(
+            cell.getJunctions().get(junction),
+            maybeJunctions -> {
+                if (maybeJunctions.isNone() || maybeJunctions.getOrNull().isEmpty()) {
+                    return MutableObservable.Companion.observe(0.0);
+                }
+                return maybeJunctions.getOrNull().get(neighbor)
+                    .map(maybeCount -> maybeCount.fold(() -> 0d, Integer::doubleValue));
+            }
+        );
     }
 
     @Override
@@ -70,4 +75,7 @@ public String toString() {
         return "junction " + junction.toString() + " present ";
     }
 
+    private void setUpObservability() {
+        setValidity(cell.observeContainsJunction(junction));
+    }
 }
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/NeighborhoodPresent.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/NeighborhoodPresent.java
index b296f13df6..71eac51956 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/NeighborhoodPresent.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/NeighborhoodPresent.java
@@ -13,6 +13,8 @@
 import it.unibo.alchemist.model.Node;
 import it.unibo.alchemist.model.Reaction;
 import it.unibo.alchemist.model.biochemistry.CellProperty;
+import it.unibo.alchemist.model.observation.MutableObservable;
+import it.unibo.alchemist.model.observation.Observable;
 
 import java.io.Serial;
 
@@ -33,8 +35,14 @@ public final class NeighborhoodPresent<T> extends AbstractNeighborCondition<T> {
      * @param node the node
      * @param environment the current environment.
      */
+    @SuppressWarnings("unchecked")
     public NeighborhoodPresent(final Environment<T, ?> environment, final Node<T> node) {
         super(environment, node);
+
+        setValidity(environment.observeNeighborhood(getNode()).map(neighborhood ->
+            neighborhood.getNeighbors().stream()
+                .anyMatch(n -> n.asPropertyOrNull(CellProperty.class) != null)
+            ));
     }
 
     @Override
@@ -44,16 +52,10 @@ public NeighborhoodPresent<T> cloneCondition(final Node<T> newNode, final Reacti
 
     @SuppressWarnings("unchecked")
     @Override
-    protected double getNeighborPropensity(final Node<T> neighbor) {
+    protected Observable<Double> observeNeighborPropensity(final Node<T> neighbor) {
         // to be eligible (p = 1), a neighbor just needs to be an instance of CellNode
-        return neighbor.asPropertyOrNull(CellProperty.class) != null ? 1d : 0d;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public boolean isValid() {
-        return getEnvironment().getNeighborhood(getNode()).getNeighbors().stream()
-                .anyMatch(n -> n.asPropertyOrNull(CellProperty.class) != null);
+        // Note: Property changes are not yet observable, so this assumes static properties for now.
+        return MutableObservable.Companion.observe(neighbor.asPropertyOrNull(CellProperty.class) != null ? 1d : 0d);
     }
 
     @Override
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/TensionPresent.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/TensionPresent.java
index 9859aaffdf..e1747410c5 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/TensionPresent.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/TensionPresent.java
@@ -32,12 +32,17 @@ public final class TensionPresent extends AbstractCondition<Double> {
     private final EnvironmentSupportingDeformableCells<?> environment;
 
     /**
-     * @param node the node
+     * @param node        the node
      * @param environment the environment
      */
     public TensionPresent(final EnvironmentSupportingDeformableCells<?> environment, final Node<Double> node) {
         super(node);
         this.environment = environment;
+        addObservableDependency(
+            environment.observeNodesWithinRange(node, environment.getMaxDiameterAmongCircularDeformableCells())
+        );
+        setPropensityContribution();
+        setValidity();
     }
 
     @Override
@@ -53,61 +58,65 @@ public Context getContext() {
         return Context.NEIGHBORHOOD;
     }
 
-    @Override
-    public double getPropensityContribution() {
-        final Node<Double> thisNode = getNode();
-        return environment.getNodesWithinRange(thisNode, environment.getMaxDiameterAmongCircularDeformableCells()).stream()
-                //.parallel()
-                .flatMap(node ->
-                    node.asPropertyOrNull(CircularCellProperty.class) != null ? Stream.of(node) : Stream.empty()
-                )
-                .mapToDouble(node -> {
-                    final double maxRn;
-                    final double minRn;
-                    final double maxRN = thisNode.asProperty(CircularDeformableCellProperty.class)
+    private void setPropensityContribution() {
+        final var thisNode = getNode();
+        setPropensity(
+            environment.observeNodesWithinRange(thisNode, environment.getMaxDiameterAmongCircularDeformableCells()).map(it ->
+                it.stream()
+                    .flatMap(node ->
+                        node.asPropertyOrNull(CircularCellProperty.class) != null ? Stream.of(node) : Stream.empty()
+                    )
+                    .mapToDouble(node -> {
+                        final double maxRn;
+                        final double minRn;
+                        final double maxRN = thisNode.asProperty(CircularDeformableCellProperty.class)
                             .getMaximumRadius();
-                    final double minRN = thisNode.asProperty(CircularDeformableCellProperty.class).getRadius();
-                    if (node.asPropertyOrNull(CircularDeformableCellProperty.class) != null) {
-                        maxRn = node.asProperty(CircularDeformableCellProperty.class).getMaximumRadius();
-                        minRn = node.asProperty(CircularDeformableCellProperty.class).getRadius();
-                    } else {
-                        maxRn = node.asProperty(CircularCellProperty.class).getRadius();
-                        minRn = maxRn;
-                    }
-                    final double distance = environment.getDistanceBetweenNodes(node, thisNode);
-                    if (maxRn + maxRN - distance < 0) {
-                        return 0;
-                    } else {
-                        if (maxRn == minRn && maxRN == minRN) {
-                            return 1;
+                        final double minRN = thisNode.asProperty(CircularDeformableCellProperty.class).getRadius();
+                        if (node.asPropertyOrNull(CircularDeformableCellProperty.class) != null) {
+                            maxRn = node.asProperty(CircularDeformableCellProperty.class).getMaximumRadius();
+                            minRn = node.asProperty(CircularDeformableCellProperty.class).getRadius();
+                        } else {
+                            maxRn = node.asProperty(CircularCellProperty.class).getRadius();
+                            minRn = maxRn;
+                        }
+                        final double distance = environment.getDistanceBetweenNodes(node, thisNode);
+                        if (maxRn + maxRN - distance < 0) {
+                            return 0;
                         } else {
-                            return (maxRn + maxRN - distance) / (maxRn + maxRN - minRn - minRN);
+                            if (maxRn == minRn && maxRN == minRN) {
+                                return 1;
+                            } else {
+                                return (maxRn + maxRN - distance) / (maxRn + maxRN - minRn - minRN);
+                            }
                         }
-                    }
-                })
-                .sum();
+                    })
+                    .sum()
+            )
+        );
     }
 
-    @Override
-    public boolean isValid() {
-        final Node<Double> thisNode = getNode();
-        return environment.getNodesWithinRange(thisNode, environment.getMaxDiameterAmongCircularDeformableCells()).stream()
-                .parallel()
-                .flatMap(n -> n.asPropertyOrNull(CircularCellProperty.class) != null
+    private void setValidity() {
+        final var thisNode = getNode();
+        setValidity(
+            environment.observeNodesWithinRange(getNode(), environment.getMaxDiameterAmongCircularDeformableCells()).map(it ->
+                it.stream()
+                    .parallel()
+                    .flatMap(n -> n.asPropertyOrNull(CircularCellProperty.class) != null
                         ? Stream.of(n)
                         : Stream.empty())
-                .anyMatch(n -> {
-                    final double maxDN = thisNode.asProperty(CircularDeformableCellProperty.class)
+                    .anyMatch(n -> {
+                        final double maxDN = thisNode.asProperty(CircularDeformableCellProperty.class)
                             .getMaximumRadius();
-                    if (n.asPropertyOrNull(CircularDeformableCellProperty.class) != null) {
-                        return environment.getDistanceBetweenNodes(n, thisNode)
+                        if (n.asPropertyOrNull(CircularDeformableCellProperty.class) != null) {
+                            return environment.getDistanceBetweenNodes(n, thisNode)
                                 < (maxDN + n.asProperty(CircularDeformableCellProperty.class)
                                 .getMaximumRadius());
-                    } else {
-                        return environment.getDistanceBetweenNodes(n, thisNode) < (maxDN
+                        } else {
+                            return environment.getDistanceBetweenNodes(n, thisNode) < (maxDN
                                 + n.asProperty(CircularCellProperty.class).getRadius());
-                    }
-                });
+                        }
+                    })
+            )
+        );
     }
-
 }
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironment.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironment.java
index 6e4544be71..fa655585e0 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironment.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironment.java
@@ -114,7 +114,7 @@ public final void moveNode(final Node<Double> node, @Nonnull final Euclidean2DPo
             super.moveNode(node, direction);
             final Neighborhood<Double> neigh = getNeighborhood(node);
             final Map<Junction, Map<Node<Double>, Integer>> jun = node
-                    .asProperty(CellProperty.class).getJunctions();
+                    .asProperty(CellProperty.class).getJunctions().getCurrent();
             jun.forEach((key, value) -> value.forEach((key1, value1) -> {
                 if (!neigh.contains(key1)) {
                     // there is a junction that links a node which isn't in the neighborhood after the movement
diff --git a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/CellProperty.kt b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/CellProperty.kt
index 5361825cda..1004f166ce 100644
--- a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/CellProperty.kt
+++ b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/CellProperty.kt
@@ -9,19 +9,25 @@
 
 package it.unibo.alchemist.model.biochemistry
 
+import arrow.core.getOrElse
 import it.unibo.alchemist.model.Node
 import it.unibo.alchemist.model.NodeProperty
 import it.unibo.alchemist.model.biochemistry.molecules.Junction
 import it.unibo.alchemist.model.geometry.Vector
+import it.unibo.alchemist.model.observation.Observable
+import it.unibo.alchemist.model.observation.Observable.ObservableExtensions.currentOrNull
+import it.unibo.alchemist.model.observation.ObservableMutableMap
+import it.unibo.alchemist.model.observation.ObservableMutableMap.ObservableMapExtensions.upsertValue
 
 /**
  * A node's capability to behave as a cell.
  */
 interface CellProperty<P : Vector<P>> : NodeProperty<Double> {
+
     /**
      * The map junction - node - quantity.
      */
-    val junctions: MutableMap<Junction, MutableMap<Node<Double>, Int>>
+    val junctions: ObservableMutableMap<Junction, ObservableMutableMap<Node<Double>, Int>>
 
     /**
      * Add a junction to the current node.
@@ -29,28 +35,31 @@ interface CellProperty<P : Vector<P>> : NodeProperty<Double> {
      * [neighbor] the neighbor node at the other side of the junction.
      */
     fun addJunction(junction: Junction, neighbor: Node<Double>) {
-        if (containsJunction(junction)) {
-            junctions[junction]?.let {
-                if (it.containsKey(neighbor)) {
-                    it[neighbor] = it[neighbor]?.plus(1) ?: 1
-                } else {
-                    it[neighbor] = 1
+        junctions.upsertValue(junction) { oldValue ->
+            oldValue?.apply {
+                upsertValue(neighbor) {
+                    when {
+                        it != null -> it + 1
+                        else -> 1
+                    }
                 }
-                junctions[junction] = it
-            }
-        } else {
-            val tmp: MutableMap<Node<Double>, Int> = LinkedHashMap(1)
-            tmp[neighbor] = 1
-            junctions[junction] = tmp
+            } ?: ObservableMutableMap(mutableMapOf(neighbor to 1))
         }
     }
 
     /**
      * Return true if a junction is present in the current node, false otherwise.
      * Note: a junction is considered present if the method junction.equals(j) return true.
-     * [junction] the junction.
+     * @param junction the junction.
+     */
+    fun containsJunction(junction: Junction): Boolean = observeContainsJunction(junction).current
+
+    /**
+     * Return an observable view of the presence of the [junction] in the current node.
+     *
+     * @param junction the junction.
      */
-    fun containsJunction(junction: Junction) = junctions.containsKey(junction)
+    fun observeContainsJunction(junction: Junction): Observable<Boolean> = junctions[junction].map { it.isSome() }
 
     /**
      * Removes a [junction] from this [node].
@@ -58,22 +67,24 @@ interface CellProperty<P : Vector<P>> : NodeProperty<Double> {
      * [neighbor] the node at the other side of the junction.
      */
     fun removeJunction(junction: Junction, neighbor: Node<Double>) {
-        if (containsJunction(junction)) {
-            val inner: MutableMap<Node<Double>, Int>? = junctions[junction]
-            inner?.let {
-                when (it[neighbor]) {
-                    1 -> it.remove(neighbor)
-                    else -> it[neighbor]?.minus(1)
-                }
-                if (it.isEmpty()) {
-                    junctions.remove(junction)
-                } else {
-                    junctions[junction] = inner
-                }
-                junction.moleculesInCurrentNode.forEach { (biomolecule, value) ->
-                    with(node) {
-                        setConcentration(biomolecule, getConcentration(biomolecule) + value)
-                    }
+        if (!containsJunction(junction)) {
+            return
+        }
+
+        val inner = junctions[junction].currentOrNull()
+        inner?.let {
+            when (it[neighbor].current.getOrElse { 0 }) {
+                1 -> it.remove(neighbor)
+                else -> it[neighbor].currentOrNull()?.minus(1)
+            }
+            if (it.isEmpty()) {
+                junctions.remove(junction)
+            } else {
+                junctions[junction] = inner
+            }
+            junction.moleculesInCurrentNode.forEach { (biomolecule, value) ->
+                with(node) {
+                    setConcentration(biomolecule, getConcentration(biomolecule) + value)
                 }
             }
         }
@@ -83,18 +94,28 @@ interface CellProperty<P : Vector<P>> : NodeProperty<Double> {
      * Returns a set of [Node]s which are linked with the current node by a junction of the type [junction].
      */
     fun getNeighborLinkWithJunction(junction: Junction): Set<Node<Double>> =
-        junctions.getOrElse(junction) { LinkedHashMap() }.keys
+        observeNeighborLinkWithJunction(junction).current
+
+    /**
+     * Returns an observable view of the set of [Node]s which are linked with the current
+     * node by a [junction].
+     *
+     * @param junction the junction to check
+     * @return an [Observable] set of the node linked with current node.
+     */
+    fun observeNeighborLinkWithJunction(junction: Junction): Observable<Set<Node<Double>>> =
+        junctions[junction].map { maybeMap -> maybeMap.map { it.current.keys }.getOrElse { LinkedHashSet() } }
 
     /**
      * Returns set of [Node]s which are linked by a junction with the current [node].
      */
-    fun getAllNodesLinkWithJunction(): Set<Node<Double>> = junctions.values.flatMap { it.keys }.toSet()
+    fun getAllNodesLinkWithJunction(): Set<Node<Double>> = junctions.current.values.flatMap { it.current.keys }.toSet()
 
     /**
      * The total number of junctions in this [node].
      */
     val junctionsCount: Int
-        get() = junctions.values.flatMap { it.values }.sum()
+        get() = junctions.current.values.flatMap { it.current.values }.sum()
 
     /**
      * The polarization versor, e.g. a versor indicating the direction in which the cell will move the next time.
@@ -102,7 +123,7 @@ interface CellProperty<P : Vector<P>> : NodeProperty<Double> {
     var polarizationVersor: P
 
     /**
-     * add [versor] to the polarization versor inside the cell; useful for considering the combination of various
+     * Add [versor] to the polarization versor inside the cell; useful for considering the combination of various
      * stimuli in a cell.
      */
     fun addPolarizationVersor(versor: P)
diff --git a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/Cell.kt b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/Cell.kt
index ac90566fdd..eeb42da4c6 100644
--- a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/Cell.kt
+++ b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/Cell.kt
@@ -13,6 +13,7 @@ import it.unibo.alchemist.model.Environment
 import it.unibo.alchemist.model.Node
 import it.unibo.alchemist.model.biochemistry.CellProperty
 import it.unibo.alchemist.model.biochemistry.molecules.Junction
+import it.unibo.alchemist.model.observation.ObservableMutableMap
 import it.unibo.alchemist.model.positions.Euclidean2DPosition
 import it.unibo.alchemist.model.properties.AbstractNodeProperty
 import kotlin.math.nextDown
@@ -30,7 +31,8 @@ constructor(
      */
     val environment: Environment<Double, Euclidean2DPosition>,
     override val node: Node<Double>,
-    override val junctions: MutableMap<Junction, MutableMap<Node<Double>, Int>> = LinkedHashMap(),
+    override val junctions: ObservableMutableMap<Junction, ObservableMutableMap<Node<Double>, Int>> =
+        ObservableMutableMap(),
 ) : AbstractNodeProperty<Double>(node),
     CellProperty<Euclidean2DPosition> {
     override var polarizationVersor: Euclidean2DPosition = Euclidean2DPosition.zero
diff --git a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/CircularCell.kt b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/CircularCell.kt
index 7ac612f9ff..36cad1081d 100644
--- a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/CircularCell.kt
+++ b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/CircularCell.kt
@@ -14,6 +14,7 @@ import it.unibo.alchemist.model.Node
 import it.unibo.alchemist.model.biochemistry.CellProperty
 import it.unibo.alchemist.model.biochemistry.CircularCellProperty
 import it.unibo.alchemist.model.biochemistry.molecules.Junction
+import it.unibo.alchemist.model.observation.ObservableMutableMap
 import it.unibo.alchemist.model.positions.Euclidean2DPosition
 import it.unibo.alchemist.model.properties.AbstractNodeProperty
 
@@ -26,7 +27,8 @@ constructor(
     environment: Environment<Double, Euclidean2DPosition>,
     override val node: Node<Double>,
     override val diameter: Double = 0.0,
-    override val junctions: MutableMap<Junction, MutableMap<Node<Double>, Int>> = LinkedHashMap(),
+    override val junctions: ObservableMutableMap<Junction, ObservableMutableMap<Node<Double>, Int>> =
+        ObservableMutableMap(),
 ) : AbstractNodeProperty<Double>(node),
     CircularCellProperty,
     CellProperty<Euclidean2DPosition> by Cell(environment, node, junctions) {
diff --git a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/CircularDeformableCell.kt b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/CircularDeformableCell.kt
index 1f5a3282b2..7ebe246d64 100644
--- a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/CircularDeformableCell.kt
+++ b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/properties/CircularDeformableCell.kt
@@ -14,6 +14,7 @@ import it.unibo.alchemist.model.Node
 import it.unibo.alchemist.model.biochemistry.CircularCellProperty
 import it.unibo.alchemist.model.biochemistry.CircularDeformableCellProperty
 import it.unibo.alchemist.model.biochemistry.molecules.Junction
+import it.unibo.alchemist.model.observation.ObservableMutableMap
 import it.unibo.alchemist.model.positions.Euclidean2DPosition
 import it.unibo.alchemist.model.properties.AbstractNodeProperty
 
@@ -27,7 +28,8 @@ constructor(
     override val node: Node<Double>,
     override val maximumDiameter: Double,
     override val rigidity: Double,
-    override val junctions: MutableMap<Junction, MutableMap<Node<Double>, Int>> = LinkedHashMap(),
+    override val junctions: ObservableMutableMap<Junction, ObservableMutableMap<Node<Double>, Int>> =
+        ObservableMutableMap(),
 ) : AbstractNodeProperty<Double>(node),
     CircularDeformableCellProperty,
     CircularCellProperty by CircularCell(
diff --git a/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/reactions/TestNeighborhoodReactionsPropensities.kt b/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/reactions/TestNeighborhoodReactionsPropensities.kt
index 21ce7a2a39..5d5570dc52 100644
--- a/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/reactions/TestNeighborhoodReactionsPropensities.kt
+++ b/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/reactions/TestNeighborhoodReactionsPropensities.kt
@@ -21,6 +21,8 @@ import it.unibo.alchemist.model.biochemistry.environments.BioRect2DEnvironment
 import it.unibo.alchemist.model.biochemistry.molecules.Junction
 import it.unibo.alchemist.model.biochemistry.startSimulationWithoutParameters
 import it.unibo.alchemist.model.linkingrules.ConnectWithinDistance
+import it.unibo.alchemist.model.observation.ObservableMap.Companion.getOrElse
+import it.unibo.alchemist.model.observation.ObservableMutableMap
 import it.unibo.alchemist.model.positions.Euclidean2DPosition
 import it.unibo.alchemist.model.timedistributions.ExponentialTime
 import kotlin.properties.Delegates
@@ -132,8 +134,8 @@ private val Node<Double>.junctionPresentPropensity: Double
             centralNode
                 .asProperty<Double, CellProperty<Euclidean2DPosition>>()
                 .junctions
-                .getOrDefault(JUNCTION, emptyMap())
-                .getOrDefault(it, 0)
+                .getOrElse(JUNCTION) { ObservableMutableMap() }
+                .getOrElse(it) { 0 }
                 .toDouble()
         }
 
diff --git a/alchemist-incarnation-protelis/src/main/java/it/unibo/alchemist/model/protelis/conditions/ComputationalRoundComplete.java b/alchemist-incarnation-protelis/src/main/java/it/unibo/alchemist/model/protelis/conditions/ComputationalRoundComplete.java
index 8cd85b6298..ff6fa260f4 100644
--- a/alchemist-incarnation-protelis/src/main/java/it/unibo/alchemist/model/protelis/conditions/ComputationalRoundComplete.java
+++ b/alchemist-incarnation-protelis/src/main/java/it/unibo/alchemist/model/protelis/conditions/ComputationalRoundComplete.java
@@ -13,6 +13,7 @@
 import it.unibo.alchemist.model.Node;
 import it.unibo.alchemist.model.Reaction;
 import it.unibo.alchemist.model.conditions.AbstractCondition;
+import it.unibo.alchemist.model.observation.Observable;
 import it.unibo.alchemist.model.protelis.actions.RunProtelisProgram;
 import it.unibo.alchemist.model.protelis.properties.ProtelisDevice;
 
@@ -38,6 +39,17 @@ public ComputationalRoundComplete(final Node<Object> node, final RunProtelisProg
         super(node);
         this.program = program;
         declareDependencyOn(this.program.asMolecule());
+        addObservableDependency(program.getObserveComputationalCycleComplete());
+    }
+
+    @Override
+    public Observable<Boolean> observeValidity() {
+        return getProgram().getObserveComputationalCycleComplete();
+    }
+
+    @Override
+    public Observable<Double> observePropensityContribution() {
+        return observeValidity().map(it -> it ? 1d : 0d);
     }
 
     @Override
@@ -58,13 +70,14 @@ public ComputationalRoundComplete cloneCondition(final Node<Object> node, final
     }
 
     @Override
-    public Context getContext() {
-        return Context.LOCAL;
+    public void dispose() {
+        super.dispose();
+        getProgram().getObserveComputationalCycleComplete().dispose();
     }
 
     @Override
-    public double getPropensityContribution() {
-        return isValid() ? 1 : 0;
+    public Context getContext() {
+        return Context.LOCAL;
     }
 
     /**
@@ -74,11 +87,6 @@ public RunProtelisProgram<?> getProgram() {
         return program;
     }
 
-    @Override
-    public boolean isValid() {
-        return program.isComputationalCycleComplete();
-    }
-
     @Override
     public String toString() {
         return program.asMolecule().getName() + " completed round";
diff --git a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt
index d3a759834c..351b553e5c 100644
--- a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt
+++ b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt
@@ -9,6 +9,7 @@
 
 package it.unibo.alchemist.model.incarnations
 
+import arrow.core.Option
 import com.google.common.cache.CacheBuilder
 import com.google.common.cache.CacheLoader
 import com.google.common.cache.LoadingCache
@@ -28,6 +29,8 @@ import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.TimeDistribution
 import it.unibo.alchemist.model.molecules.SimpleMolecule
 import it.unibo.alchemist.model.nodes.GenericNode
+import it.unibo.alchemist.model.observation.Observable
+import it.unibo.alchemist.model.observation.ObservableMap
 import it.unibo.alchemist.model.protelis.actions.RunProtelisProgram
 import it.unibo.alchemist.model.protelis.actions.SendToNeighbor
 import it.unibo.alchemist.model.protelis.conditions.ComputationalRoundComplete
@@ -358,10 +361,14 @@ class ProtelisIncarnation<P : Position<P>> : Incarnation<Any, P> {
 
         override val contents: MutableMap<Molecule, Any> get() = notImplemented()
 
+        override val observableContents: ObservableMap<Molecule, Any> get() = notImplemented()
+
         override val id: Int get() = notImplemented()
 
         override val moleculeCount: Int get() = notImplemented()
 
+        override val observeMoleculeCount: Observable<Int> get() = notImplemented()
+
         override val properties: List<NodeProperty<Any>> = emptyList()
 
         override val reactions: List<Reaction<Any>> = emptyList()
@@ -376,8 +383,12 @@ class ProtelisIncarnation<P : Position<P>> : Incarnation<Any, P> {
 
         override fun contains(molecule: Molecule): Boolean = notImplemented()
 
+        override fun observeContains(molecule: Molecule): Observable<Boolean> = notImplemented()
+
         override fun getConcentration(molecule: Molecule): Any = notImplemented()
 
+        override fun observeConcentration(molecule: Molecule): Observable<Option<Any>> = notImplemented()
+
         override fun removeConcentration(moleculeToRemove: Molecule) = notImplemented<Unit>()
 
         override fun removeReaction(reactionToRemove: Reaction<Any>) = notImplemented<Unit>()
diff --git a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/actions/RunProtelisProgram.kt b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/actions/RunProtelisProgram.kt
index 0a66003db3..ca78784be0 100644
--- a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/actions/RunProtelisProgram.kt
+++ b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/actions/RunProtelisProgram.kt
@@ -18,6 +18,9 @@ import it.unibo.alchemist.model.Node.Companion.asProperty
 import it.unibo.alchemist.model.Position
 import it.unibo.alchemist.model.Reaction
 import it.unibo.alchemist.model.molecules.SimpleMolecule
+import it.unibo.alchemist.model.observation.MutableObservable
+import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
+import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.protelis.AlchemistExecutionContext
 import it.unibo.alchemist.model.protelis.properties.ProtelisDevice
 import it.unibo.alchemist.util.RealDistributions
@@ -154,8 +157,15 @@ class RunProtelisProgram<P : Position<P>> private constructor(
      * @return true if the Program has finished its last computation,
      * and is ready to send a new message (used for dependency management)
      */
-    var isComputationalCycleComplete = false
-        private set
+    val isComputationalCycleComplete: Boolean get() = observeComputationalCycleComplete.current
+
+    /**
+     * An observable that emits updates indicating whether the computational cycle of a Protelis program
+     * has been completed. The current value of this observable is caputered by [isComputationalCycleComplete].
+     */
+    val observeComputationalCycleComplete: Observable<Boolean> get() = _observeComputationalCycleComplete
+
+    private val _observeComputationalCycleComplete: MutableObservable<Boolean> = observe(false)
 
     private val name: Molecule =
         node.reactions
@@ -208,7 +218,7 @@ class RunProtelisProgram<P : Position<P>> private constructor(
     override fun execute() {
         vm.runCycle()
         node.setConcentration(name, vm.currentValue)
-        isComputationalCycleComplete = true
+        _observeComputationalCycleComplete.update { true }
     }
 
     /*
@@ -226,7 +236,7 @@ class RunProtelisProgram<P : Position<P>> private constructor(
      * Resets the computation status (used for dependency management).
      */
     fun prepareForComputationalCycle() {
-        isComputationalCycleComplete = false
+        _observeComputationalCycleComplete.update { false }
     }
 
     /**
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/ILsaNode.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/ILsaNode.java
index 1736faa7b3..67441780a8 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/ILsaNode.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/ILsaNode.java
@@ -11,6 +11,7 @@
 
 import it.unibo.alchemist.model.Molecule;
 import it.unibo.alchemist.model.Node;
+import it.unibo.alchemist.model.observation.ObservableList;
 
 import javax.annotation.Nonnull;
 import java.util.List;
@@ -44,6 +45,11 @@ public interface ILsaNode extends Node<List<ILsaMolecule>> {
      */
     List<ILsaMolecule> getLsaSpace();
 
+    /**
+     * @return an {@link ObservableList} view of LSA Molecules in the node.
+     */
+    ObservableList<ILsaMolecule> observeLsaSpace();
+
     @Override
     List<ILsaMolecule> getConcentration(@Nonnull Molecule mol);
 
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
index 5080137ed1..7469dac091 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
@@ -11,8 +11,10 @@
 
 import it.unibo.alchemist.model.Context;
 import it.unibo.alchemist.model.Environment;
+import it.unibo.alchemist.model.Neighborhood;
 import it.unibo.alchemist.model.Node;
 import it.unibo.alchemist.model.Reaction;
+import it.unibo.alchemist.model.observation.ObservableExtensions;
 import it.unibo.alchemist.model.sapere.ILsaMolecule;
 import it.unibo.alchemist.model.sapere.ILsaNode;
 import it.unibo.alchemist.model.sapere.dsl.IExpression;
@@ -43,12 +45,28 @@ public final class LsaNeighborhoodCondition extends LsaStandardCondition {
      * @param environment the environment
      */
     public LsaNeighborhoodCondition(
-            final ILsaNode node,
-            final ILsaMolecule molecule,
-            final Environment<List<ILsaMolecule>, ?> environment
+        final ILsaNode node,
+        final ILsaMolecule molecule,
+        final Environment<List<ILsaMolecule>, ?> environment
     ) {
         super(molecule, node);
         this.environment = environment;
+
+        // We depend on every neighbor's LSA space, hence an update is triggered
+        // every time a change in node's neighborhood is emitted, or one of the
+        // members' LSA space has changed.
+        addObservableDependency(ObservableExtensions.INSTANCE.switchMap(
+            environment.observeNeighborhood(node).map(Neighborhood::getNeighbors),
+            neighbors ->
+                ObservableExtensions.INSTANCE.combineLatest(
+                    neighbors.stream()
+                        .filter(it -> it instanceof ILsaNode)
+                        .map(neighbor ->
+                            ((ILsaNode) neighbor).observeLsaSpace()
+                        ).toList(),
+                    space -> space
+                )
+        ));
     }
 
     @Override
@@ -58,9 +76,9 @@ public LsaNeighborhoodCondition cloneCondition(final Node<List<ILsaMolecule>> no
 
     @Override
     public boolean filter(
-            final List<Map<HashString, ITreeNode<?>>> matchesList,
-            final List<ILsaNode> validNodes,
-            final List<Map<ILsaNode, List<ILsaMolecule>>> retrieved
+        final List<Map<HashString, ITreeNode<?>>> matchesList,
+        final List<ILsaNode> validNodes,
+        final List<Map<ILsaNode, List<ILsaMolecule>>> retrieved
     ) {
         if (validNodes.isEmpty()) {
             return false;
@@ -126,7 +144,7 @@ public boolean filter(
                         final List<ILsaMolecule> alreadyRemoved =
                             alreadyRemovedMap.computeIfAbsent(n, k -> new ArrayList<>());
                         final List<ILsaMolecule> otherMatches =
-                                calculateMatches(partialInstance, dups, n.getLsaSpace(), alreadyRemoved);
+                            calculateMatches(partialInstance, dups, n.getLsaSpace(), alreadyRemoved);
                         if (otherMatches.isEmpty()) {
                             /*
                              * This match should be removed, but there might be
@@ -138,13 +156,13 @@ public boolean filter(
                             matchesList.remove(i);
                         } else {
                             incorporateNewMatches(
-                                    n,
-                                    otherMatches,
-                                    matches,
-                                    getMolecule(),
-                                    matchesList,
-                                    alreadyRemovedMap,
-                                    retrieved
+                                n,
+                                otherMatches,
+                                matches,
+                                getMolecule(),
+                                matchesList,
+                                alreadyRemovedMap,
+                                retrieved
                             );
                             matchesfound = true;
                             newValidNodes.add(n);
@@ -162,7 +180,7 @@ public boolean filter(
                     final List<ILsaMolecule> alreadyRemoved =
                         alreadyRemovedMap.computeIfAbsent(n, k -> new ArrayList<>());
                     final List<ILsaMolecule> otherMatches =
-                            calculateMatches(partialInstance, dups, n.getLsaSpace(), alreadyRemoved);
+                        calculateMatches(partialInstance, dups, n.getLsaSpace(), alreadyRemoved);
                     if (!otherMatches.isEmpty()) {
                         matchesPerNode.put(n, otherMatches);
                         newValidNodes.add(n);
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
index 9e08c919c7..5e12001aa6 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
@@ -13,6 +13,7 @@
 import it.unibo.alchemist.model.Context;
 import it.unibo.alchemist.model.Node;
 import it.unibo.alchemist.model.Reaction;
+import it.unibo.alchemist.model.observation.MutableObservable;
 import it.unibo.alchemist.model.sapere.ILsaMolecule;
 import it.unibo.alchemist.model.sapere.ILsaNode;
 import it.unibo.alchemist.model.sapere.dsl.IExpression;
@@ -35,7 +36,7 @@ public class LsaStandardCondition extends AbstractLsaCondition {
     private static final long serialVersionUID = 1L;
 
     private final ILsaMolecule molecule;
-    private boolean valid;
+    private final MutableObservable<Boolean> valid = MutableObservable.Companion.observe(false);
 
     /**
      * Builds an LsaStandardCondition.
@@ -47,6 +48,12 @@ public class LsaStandardCondition extends AbstractLsaCondition {
      */
     public LsaStandardCondition(final ILsaMolecule mol, final ILsaNode n) {
         super(n, Sets.newHashSet(new ILsaMolecule[] {mol}));
+
+        // we trigger the update on any change in the LSA space. Is this correct?
+        addObservableDependency(n.observeLsaSpace());
+        setValidity(valid);
+        setPropensity(MutableObservable.Companion.observe(-1d));
+
         molecule = mol;
     }
 
@@ -140,16 +147,6 @@ protected ILsaMolecule getMolecule() {
         return molecule;
     }
 
-    @Override
-    public final double getPropensityContribution() {
-        return -1;
-    }
-
-    @Override
-    public final boolean isValid() {
-        return valid;
-    }
-
     /**
      * {@inheritDoc}
      */
@@ -167,8 +164,8 @@ public String toString() {
      * @return the value which is passed.
      */
     protected final boolean makeValid(final boolean isValid) {
-        valid = isValid;
-        return valid;
+        valid.update(it -> isValid);
+        return isValid;
     }
 
 }
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/nodes/LsaNode.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/nodes/LsaNode.java
index 512a31c357..39e8817f96 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/nodes/LsaNode.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/nodes/LsaNode.java
@@ -9,15 +9,22 @@
 
 package it.unibo.alchemist.model.sapere.nodes;
 
+import arrow.core.Option;
 import it.unibo.alchemist.model.Environment;
 import it.unibo.alchemist.model.Molecule;
 import it.unibo.alchemist.model.nodes.GenericNode;
+import it.unibo.alchemist.model.observation.MutableObservable;
+import it.unibo.alchemist.model.observation.Observable;
+import it.unibo.alchemist.model.observation.ObservableList;
+import it.unibo.alchemist.model.observation.ObservableMutableList;
 import it.unibo.alchemist.model.sapere.ILsaMolecule;
 import it.unibo.alchemist.model.sapere.ILsaNode;
 import it.unibo.alchemist.model.sapere.dsl.IExpression;
 import it.unibo.alchemist.model.sapere.dsl.impl.Expression;
 import it.unibo.alchemist.model.sapere.dsl.impl.NumTreeNode;
 import it.unibo.alchemist.model.sapere.molecules.LsaMolecule;
+import kotlin.Unit;
+import org.jetbrains.annotations.NotNull;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -37,7 +44,7 @@ public final class LsaNode extends GenericNode<List<ILsaMolecule>> implements IL
     private static final long serialVersionUID = -2167025208984968645L;
     private static final ILsaMolecule ZEROMOL = new LsaMolecule("0");
 
-    private final List<ILsaMolecule> instances = new ArrayList<>();
+    private final ObservableMutableList<ILsaMolecule> instances = new ObservableMutableList<>();
 
     /**
      * @param environment
@@ -45,16 +52,18 @@ public final class LsaNode extends GenericNode<List<ILsaMolecule>> implements IL
      */
     public LsaNode(final Environment<List<ILsaMolecule>, ?> environment) {
         super(environment);
+        this.instances.onChange(this, this::updateContents);
     }
 
     @Override
-    public boolean contains(@Nonnull final Molecule molecule) {
+    @NotNull
+    public Observable<Boolean> observeContains(@NotNull final Molecule molecule) {
         if (molecule instanceof final ILsaMolecule toMatch) {
             synchronized (instances) {
-                return instances.stream().anyMatch(mol -> mol.matches(toMatch));
+                return instances.map(molecules -> molecules.stream().anyMatch(mol -> mol.matches(toMatch)));
             }
         }
-        return false;
+        return MutableObservable.Companion.observe(false);
     }
 
     @Override
@@ -64,69 +73,48 @@ protected List<ILsaMolecule> createT() { // NOPMD: this must return null, not an
     }
 
     @Override
-    public int getMoleculeCount() {
+    @NotNull
+    public Observable<Integer> getObserveMoleculeCount() {
         synchronized (instances) {
-            return instances.size();
+            return instances.getObservableSize();
         }
     }
 
     @Override
-    public List<ILsaMolecule> getConcentration(@Nonnull final Molecule m) {
-        if (!(m instanceof final ILsaMolecule mol)) {
-            throw new IllegalArgumentException(m + " is not a compatible molecule type");
+    @NotNull
+    public Observable<Option<List<ILsaMolecule>>> observeConcentration(@NotNull final Molecule molecule) {
+        if (!(molecule instanceof final ILsaMolecule mol)) {
+            throw new IllegalArgumentException(molecule + " is not a compatible molecule type");
         }
-        final ArrayList<ILsaMolecule> listMol = new ArrayList<>();
         synchronized (instances) {
-            for (final ILsaMolecule instance : instances) {
-                if (mol.matches(instance)) {
-                    listMol.add(instance);
+            return instances.map(current -> {
+                final ArrayList<ILsaMolecule> res = new ArrayList<>();
+                for (final ILsaMolecule instance : current) {
+                    if (mol.matches(instance)) {
+                        res.add(instance);
+                    }
                 }
-            }
+                return Option.fromNullable(res);
+            });
         }
-        return listMol;
     }
 
     @Override
-    @Nonnull
-    public Map<Molecule, List<ILsaMolecule>> getContents() {
-        // Create a defensive copy to avoid ConcurrentModificationException
-        final List<ILsaMolecule> instancesCopy;
-        synchronized (instances) {
-            instancesCopy = new ArrayList<>(instances);
-        }
-        final Map<Molecule, List<ILsaMolecule>> res = new HashMap<>(instancesCopy.size(), 1.0f);
-        for (final ILsaMolecule m : instancesCopy) {
-            final List<ILsaMolecule> l;
-            if (res.containsKey(m)) {
-                /*
-                 * Safe by construction.
-                 */
-                l = res.get(m);
-            } else {
-                l = new ArrayList<>(1);
-                l.add(ZEROMOL);
-                res.put(m, l);
-            }
-            final Double v = (Double) l.get(0).getArg(0).getRootNodeData() + 1;
-            final IExpression e = new Expression(new NumTreeNode(v));
-            l.set(0, new LsaMolecule(Collections.singletonList(e)));
-        }
-        return res;
+    public List<ILsaMolecule> getLsaSpace() {
+        return Collections.unmodifiableList(observeLsaSpace().toList());
     }
 
     @Override
-    public List<ILsaMolecule> getLsaSpace() {
-        synchronized (instances) {
-            return Collections.unmodifiableList(new ArrayList<>(instances));
-        }
+    public ObservableList<ILsaMolecule> observeLsaSpace() {
+        return instances;
     }
 
     @Override
     public boolean removeConcentration(final ILsaMolecule matchedInstance) {
         synchronized (instances) {
-            for (int i = 0; i < instances.size(); i++) {
+            for (int i = 0; i < instances.getObservableSize().getCurrent(); i++) {
                 if (matchedInstance.matches(instances.get(i))) {
-                    instances.remove(i);
+                    instances.removeAt(i);
                     return true;
                 }
             }
@@ -157,7 +145,28 @@ public void setConcentration(@Nonnull final Molecule molecule, final List<ILsaMo
     @Override
     @Nonnull
     public String toString() {
-        return getId() + " contains: " + instances.toString();
+        return getId() + " contains: " + instances.getCurrent();
     }
 
+    private Unit updateContents(final List<? extends ILsaMolecule> currentInstances) {
+        final Map<Molecule, List<ILsaMolecule>> res = new HashMap<>(currentInstances.size(), 1.0f);
+        for (final ILsaMolecule m : currentInstances) {
+            final List<ILsaMolecule> l;
+            if (res.containsKey(m)) {
+                /*
+                 * Safe by construction.
+                 */
+                l = res.get(m);
+            } else {
+                l = new ArrayList<>(1);
+                l.add(ZEROMOL);
+                res.put(m, l);
+            }
+            final Double v = (Double) l.get(0).getArg(0).getRootNodeData() + 1;
+            final IExpression e = new Expression(new NumTreeNode(v));
+            l.set(0, new LsaMolecule(Collections.singletonList(e)));
+        }
+        getObservableContents().clearAndPutAll(res);
+        return null;
+    }
 }
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
index 9a04235d57..ce103a5c14 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
@@ -27,6 +27,10 @@
 import it.unibo.alchemist.model.Time;
 import it.unibo.alchemist.model.TimeDistribution;
 import it.unibo.alchemist.model.maps.MapEnvironment;
+import it.unibo.alchemist.model.observation.MutableObservable;
+import it.unibo.alchemist.model.observation.Observable;
+import it.unibo.alchemist.model.observation.ObservableMutableSet;
+import it.unibo.alchemist.model.observation.ObservableSet;
 import it.unibo.alchemist.model.reactions.AbstractReaction;
 import it.unibo.alchemist.model.sapere.ILsaMolecule;
 import it.unibo.alchemist.model.sapere.ILsaNode;
@@ -538,6 +542,8 @@ private static class SGFakeConditionAction implements Action<List<ILsaMolecule>>
         private static final long serialVersionUID = 1L;
         private static final ListSet<Dependency> DEPENDENCY = ImmutableListSet.of(Dependency.EVERYTHING);
         private final Molecule mol;
+        private final Observable<Boolean> validity = MutableObservable.Companion.observe(false);
+        private final Observable<Double> propensity = MutableObservable.Companion.observe(0.0);
 
         SGFakeConditionAction(final Molecule m) {
             super();
@@ -574,6 +580,11 @@ public ListSet<? extends Dependency> getInboundDependencies() {
             return DEPENDENCY;
         }
 
+        @Override
+        public ObservableSet<? extends Observable<?>> observeInboundDependencies() {
+            return new ObservableMutableSet<>();
+        }
+
         @Nonnull
         @Override
         public ListSet<? extends Dependency> getOutboundDependencies() {
@@ -587,12 +598,28 @@ public Node<List<ILsaMolecule>> getNode() {
 
         @Override
         public double getPropensityContribution() {
-            return 0;
+            return observePropensityContribution().getCurrent();
+        }
+
+        @Override
+        public Observable<Double> observePropensityContribution() {
+            return propensity;
         }
 
         @Override
         public boolean isValid() {
-            return false;
+            return observeValidity().getCurrent();
+        }
+
+        @Override
+        public Observable<Boolean> observeValidity() {
+            return validity;
+        }
+
+        @Override
+        public void dispose() {
+            observeValidity().dispose();
+            observePropensityContribution().dispose();
         }
 
         @Override
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java
index e58b03c098..958ea19215 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java
@@ -184,8 +184,14 @@ public void execute() {
          */
         for (final Entry<ILsaNode, List<ILsaMolecule>> entry : toRemove.entrySet()) {
             final ILsaNode n = entry.getKey();
+            final List<ILsaMolecule> currentSpace = n.getLsaSpace();
             for (final ILsaMolecule m : entry.getValue()) {
-                n.removeConcentration(m);
+                for (final ILsaMolecule molecule : currentSpace) {
+                    if (m.matches(molecule)) {
+                        n.removeConcentration(m);
+                        break;
+                    }
+                }
             }
         }
         /*
diff --git a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/RunScafiProgram.scala b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/RunScafiProgram.scala
index c40cfd6b4c..986713d45a 100644
--- a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/RunScafiProgram.scala
+++ b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/RunScafiProgram.scala
@@ -9,6 +9,7 @@
 package it.unibo.alchemist.model.scafi.actions
 
 import it.unibo.alchemist.model.actions.AbstractLocalAction
+import it.unibo.alchemist.model.observation.{MutableObservable, Observable}
 import it.unibo.alchemist.model.{Node, Position, Reaction}
 import it.unibo.alchemist.model.molecules.SimpleMolecule
 import it.unibo.alchemist.model.{Time => AlchemistTime, _}
@@ -83,7 +84,7 @@ sealed class RunScafiProgram[T, P <: Position[P]](
   lazy val nodeManager = new SimpleNodeManager(node)
   private var neighborhoodManager: Map[ID, NeighborData[P]] = Map()
   private val commonNames = new ScafiIncarnationForAlchemist.StandardSensorNames {}
-  private var completed = false
+  private val _completed = MutableObservable.Companion.observe[Boolean](false)
   declareDependencyTo(Dependency.EVERY_MOLECULE)
 
   def asMolecule = programNameMolecule
@@ -187,16 +188,18 @@ sealed class RunScafiProgram[T, P <: Position[P]](
     node.setConcentration(programName, computed.root[T]())
     val toSend = NeighborData(computed, position, alchemistCurrentTime)
     neighborhoodManager = neighborhoodManager + (node.getId -> toSend)
-    completed = true
+    _completed.update(_ => true)
   }
 
   def sendExport(id: ID, exportData: NeighborData[P]): Unit = neighborhoodManager += id -> exportData
 
   def getExport(id: ID): Option[NeighborData[P]] = neighborhoodManager.get(id)
 
-  def isComputationalCycleComplete: Boolean = completed
+  def isComputationalCycleComplete: Boolean = _completed.getCurrent
 
-  def prepareForComputationalCycle: Unit = completed = false
+  def observeComputationalCycleComplete: Observable[Boolean] = _completed
+
+  def prepareForComputationalCycle: Unit = _completed.update(_ => false)
 
 }
 
diff --git a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/conditions/ScafiComputationalRoundComplete.scala b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/conditions/ScafiComputationalRoundComplete.scala
index 3cb844bda4..f188023f93 100644
--- a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/conditions/ScafiComputationalRoundComplete.scala
+++ b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/conditions/ScafiComputationalRoundComplete.scala
@@ -17,6 +17,7 @@ import it.unibo.alchemist.model.{Condition, Context, Node, Reaction}
 final class ScafiComputationalRoundComplete[T](val device: ScafiDevice[T], val program: RunScafiProgram[_, _])
     extends AbstractCondition(device.getNode) {
   declareDependencyOn(this.program.asMolecule)
+  addObservableDependency(program.observeComputationalCycleComplete)
 
   override def cloneCondition(node: Node[T], reaction: Reaction[T]): Condition[T] = {
     ScafiIncarnationUtils.runInScafiDeviceContext[T, Condition[T]](
diff --git a/alchemist-loading/build.gradle.kts b/alchemist-loading/build.gradle.kts
index b3077f26e2..3b8010fde6 100644
--- a/alchemist-loading/build.gradle.kts
+++ b/alchemist-loading/build.gradle.kts
@@ -28,7 +28,6 @@ dependencies {
     implementation(kotlin("scripting-jvm"))
     implementation(kotlin("scripting-jvm-host"))
     implementation(libs.apache.commons.lang3)
-    implementation(libs.arrow.core)
     implementation(libs.dsiutils)
     implementation(libs.graphstream.core)
     implementation(libs.graphstream.algo)
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/loader/LoadingSystem.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/loader/LoadingSystem.kt
index 4b53e86492..862fdccba2 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/loader/LoadingSystem.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/loader/LoadingSystem.kt
@@ -15,6 +15,7 @@ import it.unibo.alchemist.boundary.exporters.GlobalExporter
 import it.unibo.alchemist.boundary.loader.LoadingSystemLogger.logger
 import it.unibo.alchemist.boundary.loader.syntax.AlchemistYamlSyntax
 import it.unibo.alchemist.core.Engine
+import it.unibo.alchemist.core.ReactiveEngine
 import it.unibo.alchemist.core.Simulation
 import it.unibo.alchemist.model.Deployment
 import it.unibo.alchemist.model.Environment
@@ -149,7 +150,12 @@ internal abstract class LoadingSystem(private val originalContext: Context, priv
             val engine: Simulation<T, P> = SimulationModel
                 .visitBuilding<Simulation<T, P>>(context, engineDescriptor)
                 ?.getOrThrow()
-                ?: Engine(environment)
+                ?: if (System.getProperty("alchemist.engine", "default") == "reactive") {
+                        logger.warn("Using experimental reactive APIs")
+                        ReactiveEngine(environment)
+                    } else {
+                        Engine(environment)
+                    }
             // Attach monitors
             monitors.forEach(engine::addOutputMonitor)
             // Attach data exporters
diff --git a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestReactiveEngineLoading.kt b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestReactiveEngineLoading.kt
new file mode 100644
index 0000000000..5e405d4672
--- /dev/null
+++ b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestReactiveEngineLoading.kt
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2010-2023, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.test
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.types.shouldBeInstanceOf
+import it.unibo.alchemist.boundary.LoadAlchemist
+import it.unibo.alchemist.core.ReactiveEngine
+import it.unibo.alchemist.model.positions.Euclidean2DPosition
+import org.kaikikm.threadresloader.ResourceLoader
+
+class TestReactiveEngineLoading : StringSpec({
+
+    "It should be possible to load a simulation with the ReactiveEngine via YAML overrides" {
+        val yaml = "synthetic/scalavar.yml"
+        val overrides = listOf(
+            """
+            engine:
+                type: it.unibo.alchemist.core.ReactiveEngine
+            """.trimIndent(),
+        )
+
+        val resource = ResourceLoader.getResource(yaml)
+        val loader = LoadAlchemist.from(resource, overrides)
+        val simulation = loader.getDefault<Any, Euclidean2DPosition>()
+
+        simulation.shouldBeInstanceOf<ReactiveEngine<Any, Euclidean2DPosition>>()
+
+        simulation.play()
+        simulation.run()
+        simulation.error.isPresent shouldBe false
+    }
+})
diff --git a/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/linkingrules/LinkNodesWithinRoutingRange.java b/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/linkingrules/LinkNodesWithinRoutingRange.java
index 88df83bb59..75c5618e77 100644
--- a/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/linkingrules/LinkNodesWithinRoutingRange.java
+++ b/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/linkingrules/LinkNodesWithinRoutingRange.java
@@ -41,7 +41,8 @@ public LinkNodesWithinRoutingRange(final double r) {
     @Override
     public Neighborhood<T> computeNeighborhood(final Node<T> center, final Environment<T, GeoPosition> environment) {
         if (environment instanceof final MapEnvironment<T, ?, ?> menv) {
-            final Stream<Node<T>> stream = menv.getNodesWithinRange(center, range).parallelStream();
+            final Stream<? extends Node<T>> stream =
+                menv.getNodesWithinRange(center, range).parallelStream();
             final List<Node<T>> filtered = stream
                     .filter(node -> menv.computeRoute(center, node).length() < range)
                     .collect(Collectors.toList());
diff --git a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
index b306fdf1b7..e599a73472 100644
--- a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
+++ b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
@@ -9,6 +9,7 @@
 
 package it.unibo.alchemist.model.physics.reactions
 
+import arrow.core.getOrElse
 import it.unibo.alchemist.model.Action
 import it.unibo.alchemist.model.Actionable
 import it.unibo.alchemist.model.Condition
@@ -17,9 +18,16 @@ import it.unibo.alchemist.model.Environment
 import it.unibo.alchemist.model.GlobalReaction
 import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.TimeDistribution
+import it.unibo.alchemist.model.observation.Disposable
+import it.unibo.alchemist.model.observation.EventObservable
+import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
+import it.unibo.alchemist.model.observation.Observable
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.merge
+import it.unibo.alchemist.model.observation.ObservableExtensions.combineLatest
 import it.unibo.alchemist.model.physics.PhysicsDependency
 import it.unibo.alchemist.model.physics.environments.Dynamics2DEnvironment
 import it.unibo.alchemist.model.timedistributions.DiracComb
+import java.util.ArrayList
 import org.danilopianini.util.ImmutableListSet
 import org.danilopianini.util.ListSet
 
@@ -49,13 +57,50 @@ class PhysicsUpdate<T>(
 
     override val tau: Time get() = timeDistribution.nextOccurence
 
+    override val rescheduleRequest: EventObservable = EventObservable()
+
     override var actions: List<Action<T>> = listOf()
 
+    private var validity: Observable<Boolean> = observe(true)
+
+    private var canExecute: Boolean = true
+
+    private val subscriptions: MutableList<Observable<*>> = ArrayList()
+
     override var conditions: List<Condition<T>> = listOf()
+        set(value) {
+            field = value
+            field.forEach(Disposable::dispose)
+
+            subscriptions.forEach { it.stopWatching(this) }
+            subscriptions.clear()
+
+            validity.dispose()
+
+            value.forEach { condition ->
+                condition.observeInboundDependencies().merge().apply {
+                    onChange(this@PhysicsUpdate) { rescheduleRequest.emit() }
+                    subscriptions.add(this)
+                }
+            }
+
+            validity = value.takeIf { it.isNotEmpty() }
+                ?.map { it.observeValidity() }
+                ?.combineLatest { validities -> validities.all { it } }
+                ?.map { it.getOrElse { true } } // none means empty set of conditions i.e. always true.
+                ?.apply {
+                    onChange(this@PhysicsUpdate) { canExecute = it }
+                    subscriptions.add(this)
+                } ?: observe(true)
+
+            rescheduleRequest.emit()
+        }
 
     override fun compareTo(other: Actionable<T>): Int = tau.compareTo(other.tau)
 
-    override fun canExecute(): Boolean = conditions.all { it.isValid }
+    override fun canExecute(): Boolean = canExecute
+
+    override fun observeCanExecute(): Observable<Boolean> = validity
 
     override fun execute() {
         environment.updatePhysics(1 / rate)
diff --git a/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt b/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
index 168c472ee2..15605822d8 100644
--- a/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
+++ b/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
@@ -17,6 +17,10 @@ import it.unibo.alchemist.model.Environment
 import it.unibo.alchemist.model.GlobalReaction
 import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.TimeDistribution
+import it.unibo.alchemist.model.observation.EventObservable
+import it.unibo.alchemist.model.observation.Observable
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.combineLatest
+import it.unibo.alchemist.model.observation.ObservableMutableSet
 import org.danilopianini.util.ListSet
 import org.danilopianini.util.ListSets
 
@@ -26,16 +30,30 @@ class GlobalTestReaction<T>(val environment: Environment<T, *>, override val tim
 
     override fun canExecute(): Boolean = conditions.all { it.isValid }
 
+    override fun observeCanExecute(): Observable<Boolean> = validity
+
     override fun execute() = timeDistribution.update(timeDistribution.nextOccurence, true, 1.0, environment)
 
     override var actions: List<Action<T>> = emptyList()
 
     override var conditions: List<Condition<T>> = emptyList()
+        set(value) {
+            field = value
+            observableConditions.clearAndAddAll(value.toSet())
+        }
+
+    private val observableConditions: ObservableMutableSet<Condition<T>> = ObservableMutableSet()
+
+    private val validity = observableConditions.combineLatest({
+        it.observeValidity()
+    }) { validities -> validities.all { it } }
 
     override val outboundDependencies: ListSet<out Dependency> = ListSets.emptyListSet()
 
     override val inboundDependencies: ListSet<out Dependency> = ListSets.emptyListSet()
 
+    override val rescheduleRequest: Observable<Unit> = EventObservable()
+
     override fun update(currentTime: Time, hasBeenExecuted: Boolean, environment: Environment<T, *>) = Unit
 
     override fun initializationComplete(atTime: Time, environment: Environment<T, *>) = Unit
diff --git a/build.gradle.kts b/build.gradle.kts
index dcaf7b7a20..3c1110c657 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -64,6 +64,9 @@ allprojects {
         }
         useJUnitPlatform()
         maxHeapSize = "1g"
+        "alchemist.engine".let { property ->
+            System.getProperty(property)?.let { systemProperty(property, it) }
+        }
     }
 
     tasks.withType<SpotBugsTask>().configureEach {
diff --git a/run_all_tests_reactive.sh b/run_all_tests_reactive.sh
new file mode 100755
index 0000000000..86b2207a9e
--- /dev/null
+++ b/run_all_tests_reactive.sh
@@ -0,0 +1,2 @@
+#!/bin/bash
+./gradlew -Dalchemist.engine=reactive test

From aca51b88ade52ad6d5845b7e5aea1193ab272b71 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi@jetbrains.com>
Date: Mon, 19 Jan 2026 12:04:01 +0100
Subject: [PATCH 02/29] docs: improve Javadoc

---
 .../model/observation/DerivedObservable.kt    | 24 +++++++++++++++++--
 .../model/observation/EventObservable.kt      |  9 +++++++
 .../alchemist/model/observation/Observable.kt |  2 +-
 .../it/unibo/alchemist/core/AbstractEngine.kt |  7 ++++++
 .../model/linkingrules/AdaptiveRange.java     |  3 ++-
 .../model/reactions/AbstractReaction.java     | 23 ++++--------------
 6 files changed, 46 insertions(+), 22 deletions(-)

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
index 9ba47c3b2c..8dabb068de 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
@@ -15,8 +15,10 @@ import arrow.core.some
 import java.util.Collections
 
 /**
- * An abstract implementation of the `Observable` interface designed to support observables whose states
- * are derived from other data sources. Manages the lifecycle of observation and update propagation.
+ * An abstract implementation of the [Observable] interface designed to support observables whose states
+ * are derived from other data sources. Manages the lifecycle of observation and update propagation while
+ * keeping a minimal set of active subscriptions with the underlying observables. Moreover, observation of
+ * the sources is enabled if only there are observers registered with this derived observable.
  *
  * @param emitOnDistinct whether to emit when the new derived value is different from the current one.
  * @param T The type of data being observed.
@@ -80,10 +82,28 @@ abstract class DerivedObservable<T>(private val emitOnDistinct: Boolean = true)
         cached = none()
     }
 
+    /**
+     * Initiates monitoring for changes or updates in the implementing class.
+     * This method should enable necessary mechanisms to observe and react to changes
+     * based on the specific implementation of the derived class.
+     */
     protected abstract fun startMonitoring()
 
+    /**
+     * Stops monitoring for changes or updates in the implementing class.
+     * This method should disable any active observation mechanisms and ensure
+     * that resources or listeners associated with monitoring are appropriately released.
+     * It is intended to complement the `startMonitoring` function.
+     */
     protected abstract fun stopMonitoring()
 
+    /**
+     * Computes and returns a fresh value of type [T]. This method is expected to be implemented
+     * in derived classes to provide a new value that represents the updated state or computation
+     * result of the observable entity.
+     *
+     * @return a fresh, computed value of type [T]
+     */
     protected abstract fun computeFresh(): T
 
     protected fun updateAndNotify(newValue: T) {
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt
index 97228cfaaf..79f35cdef0 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt
@@ -1,3 +1,12 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
 package it.unibo.alchemist.model.observation
 
 /**
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
index 58e0540d87..4ae5939f2a 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
@@ -176,7 +176,7 @@ interface MutableObservable<T> : Observable<T> {
     }
 
     /**
-     * Factory methods container.
+     * Factories and extension methods container.
      */
     companion object {
 
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/AbstractEngine.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/AbstractEngine.kt
index edc32f9dd1..6655df9df1 100644
--- a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/AbstractEngine.kt
+++ b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/AbstractEngine.kt
@@ -309,6 +309,13 @@ abstract class AbstractEngine<T, P : Position<out P>>(private val environment: E
         }
     }
 
+    /**
+     * Initializes the simulation engine.
+     *
+     * This method is called during the setup phase of the simulation engine and is responsible
+     * for preparing all necessary internal states and resources required for the engine's execution,
+     * e.g. initial scheduling of global and nodes' reactions.
+     */
     protected abstract fun initialize()
 
     /**
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/AdaptiveRange.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/AdaptiveRange.java
index 6c1c2e9c80..33ca195dbe 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/AdaptiveRange.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/AdaptiveRange.java
@@ -16,6 +16,7 @@
 import it.unibo.alchemist.model.Node;
 import it.unibo.alchemist.model.Position;
 import it.unibo.alchemist.model.neighborhoods.Neighborhoods;
+import org.danilopianini.util.ListSet;
 
 import java.io.Serial;
 import java.util.stream.Collectors;
@@ -179,7 +180,7 @@ public final Neighborhood<T> computeNeighborhood(final Node<T> center, final Env
             ranges.put(center.getId(), getRange());
         }
         final double curRange = ranges.get(center.getId());
-        final var potentialNeighs = environment.getNodesWithinRange(center, curRange);
+        final ListSet<Node<T>> potentialNeighs = environment.getNodesWithinRange(center, curRange);
         final Neighborhood<T> neigh = Neighborhoods.make(environment, center, potentialNeighs.stream()
                 .filter(neighbor -> !conditionForRemoval(environment, center, neighbor, curRange, ranges.get(neighbor.getId())))
                 .collect(Collectors.toList()));
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
index 1875c3c903..e7f4eca92d 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
@@ -241,22 +241,6 @@ public final int hashCode() {
         return hash;
     }
 
-    /**
-     * This method is called when the environment has completed its
-     * initialization. Can be used by this reaction to compute its next
-     * execution time - in case such computation requires an inspection of the
-     * environment.
-     * <br/>
-     * <b>NOTE</b>: this method ensures that the observable dependencies
-     * (i.e. observable conditions) are properly initialized with
-     * {@link #initializeObservableConditions()}.
-     * Subclasses should override {@link #onInitializationComplete(Time, Environment)}
-     * to add custom initialization logic.
-     *
-     * @param atTime      the time at which the initialization of this reaction was
-     *                    accomplished
-     * @param environment the environment
-     */
     @Override
     public final void initializationComplete(@Nonnull final Time atTime, @Nonnull final Environment<T, ?> environment) {
         initializeObservableConditions();
@@ -264,8 +248,11 @@ public final void initializationComplete(@Nonnull final Time atTime, @Nonnull fi
     }
 
     /**
-     * This method is called by {@link #initializationComplete(Time, Environment)}
-     * after the observable dependencies have been initialized.
+     * This method is called when the environment has completed its
+     * initialization. Can be used by this reaction to compute its next
+     * execution time - in case such computation requires an inspection of the
+     * environment. At the time this method is called, all observable
+     * dependencies have been already initialized.
      * Subclasses can override this to perform custom initialization (e.g. initial update).
      *
      * @param atTime      the time at which the initialization of this reaction was

From 5a0850f168264993cb767bb2c08020e0e5913a36 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Wed, 21 Jan 2026 16:55:48 +0100
Subject: [PATCH 03/29] chore(api): provide a way to register to an observable
 without triggering callback invocation

---
 .../model/observation/EventObservable.kt      |  4 ++--
 .../alchemist/model/observation/Observable.kt | 23 +++++++++++++++----
 .../model/observation/ObservableExtensions.kt |  4 ++--
 .../model/observation/ObservableList.kt       |  7 +++---
 .../model/observation/ObservableMap.kt        |  4 ++--
 .../model/observation/ObservableSet.kt        | 14 ++---------
 .../model/observation/ObservableTest.kt       | 18 +++++++++++++++
 7 files changed, 48 insertions(+), 26 deletions(-)

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt
index 79f35cdef0..41431425e9 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/EventObservable.kt
@@ -33,9 +33,9 @@ class EventObservable : Observable<Unit> {
         observingCallbacks.values.forEach { callbacks -> callbacks.forEach { it(Unit) } }
     }
 
-    override fun onChange(registrant: Any, callback: (Unit) -> Unit) {
+    override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (Unit) -> Unit) {
         observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
-        callback(current)
+        if (invokeOnRegistration) callback(current)
     }
 
     override fun stopWatching(registrant: Any) {
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
index 4ae5939f2a..aee2bbb3e8 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
@@ -40,7 +40,18 @@ interface Observable<T> : Disposable {
      * @param callback   The callback to be executed when the observable's state changes. It receives
      *                   the updated value of the observable as an argument.
      */
-    fun onChange(registrant: Any, callback: (T) -> Unit)
+    fun onChange(registrant: Any, callback: (T) -> Unit) = onChange(registrant, true, callback)
+
+    /**
+     * Registers a callback to be notified of changes in the observable. The callback is invoked
+     * whenever the state of the observable changes.
+     *
+     * @param registrant The entity registering the callback.
+     * @param invokeOnRegistration Whether the callback should be invoked immediately upon registration.
+     * @param callback   The callback to be executed when the observable's state changes. It receives
+     *                   the updated value of the observable as an argument.
+     */
+    fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (T) -> Unit)
 
     /**
      * Unregisters the specified registrant from watching for changes or updates in the observable.
@@ -140,10 +151,10 @@ interface Observable<T> : Disposable {
 
                 override val observingCallbacks: MutableMap<Any, List<(T) -> Unit>> = mutableMapOf()
 
-                override fun onChange(registrant: Any, callback: (T) -> Unit) {
+                override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (T) -> Unit) {
                     observers += registrant
                     observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
-                    this@asMutable.onChange(this to registrant, callback)
+                    this@asMutable.onChange(this to registrant, invokeOnRegistration, callback)
                 }
 
                 override fun stopWatching(registrant: Any) {
@@ -201,8 +212,10 @@ interface MutableObservable<T> : Observable<T> {
 
             override val observers: List<Any> get() = observingCallbacks.keys.toList()
 
-            override fun onChange(registrant: Any, callback: (T) -> Unit) {
-                callback(current)
+            override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (T) -> Unit) {
+                if (invokeOnRegistration) {
+                    callback(current)
+                }
                 observingCallbacks[registrant] = observingCallbacks[registrant]?.let {
                     it + callback
                 } ?: listOf(callback)
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt
index e9877ba96f..17c133c262 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt
@@ -161,10 +161,10 @@ object ObservableExtensions {
 
             override val observableSize: Observable<Int> = backing.map { it.size }
 
-            override fun onChange(registrant: Any, callback: (Set<T>) -> Unit) {
+            override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (Set<T>) -> Unit) {
                 observers += registrant
                 observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
-                backing.onChange(this to registrant, callback)
+                backing.onChange(this to registrant, invokeOnRegistration, callback)
             }
 
             override fun stopWatching(registrant: Any) {
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt
index 1b46a7dbc6..50d9b26d3a 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt
@@ -27,10 +27,11 @@ interface ObservableList<T> : Observable<List<T>> {
      * The callback will be invoked with the current list of items as a parameter.
      *
      * @param registrant The object registering for change notifications. Used to manage the lifecycle of the observer.
+     * @param invokeOnRegistration whether the callback should be invoked on registration
      * @param callback The function to be invoked whenever the list changes. It receives the current list of items as
      *                 a parameter.
      */
-    override fun onChange(registrant: Any, callback: (List<T>) -> Unit)
+    override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (List<T>) -> Unit)
 
     /**
      * Returns the element at the specified index in the list.
@@ -186,9 +187,9 @@ class ObservableMutableList<T> : ObservableList<T> {
         }
     }
 
-    override fun onChange(registrant: Any, callback: (List<T>) -> Unit) {
+    override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (List<T>) -> Unit) {
         observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
-        callback(toList())
+        if (invokeOnRegistration) callback(toList())
     }
 
     override fun stopWatching(registrant: Any) {
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
index 570882a6cc..08a1af8fb9 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
@@ -167,9 +167,9 @@ open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> =
         }
     }
 
-    override fun onChange(registrant: Any, callback: (Map<K, V>) -> Unit) {
+    override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (Map<K, V>) -> Unit) {
         observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
-        callback(current.toMap())
+        if (invokeOnRegistration) callback(current.toMap())
     }
 
     override fun stopWatching(registrant: Any) {
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt
index 37b6032318..a7472091f9 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt
@@ -23,16 +23,6 @@ interface ObservableSet<T> : Observable<Set<T>> {
      */
     val observableSize: Observable<Int>
 
-    /**
-     * Observes changes to the set and triggers the provided callback function whenever the set changes.
-     * The callback will be invoked with the current set of items as a parameter.
-     *
-     * @param registrant The object registering for change notifications. Used to manage the lifecycle of the observer.
-     * @param callback The function to be invoked whenever the set changes. It receives the current set of items as
-     *                 a parameter.
-     */
-    override fun onChange(registrant: Any, callback: (Set<T>) -> Unit)
-
     /**
      * Observes the membership status of a specific item in the set.
      * The returned observable will emit `true` if the item is a member of the set,
@@ -146,9 +136,9 @@ class ObservableMutableSet<T> : ObservableSet<T> {
         toAdd.forEach(::add)
     }
 
-    override fun onChange(registrant: Any, callback: (Set<T>) -> Unit) {
+    override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (Set<T>) -> Unit) {
         observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
-        backing.onChange(this to registrant) { callback(it.keys.toSet()) }
+        backing.onChange(this to registrant, invokeOnRegistration) { callback(it.keys.toSet()) }
     }
 
     override fun stopWatching(registrant: Any) {
diff --git a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableTest.kt b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableTest.kt
index 59de8e7b9b..723e1a6e99 100644
--- a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableTest.kt
+++ b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableTest.kt
@@ -39,6 +39,24 @@ class ObservableTest : FunSpec({
             lastSeen shouldBe 42
         }
 
+        test("`onChange` with invokeOnRegistration = false should not emit current value") {
+            val observable = observe(42)
+            var lastSeen: Int? = null
+
+            observable.onChange(this, false) { lastSeen = it }
+
+            lastSeen shouldBe null
+        }
+
+        test("`onChange` with invokeOnRegistration = true should emit current value") {
+            val observable = observe(42)
+            var lastSeen: Int? = null
+
+            observable.onChange(this, true) { lastSeen = it }
+
+            lastSeen shouldBe 42
+        }
+
         test("`update` should return previous value and update current") {
             val observable = observe(0)
 

From 4e59b41bdc1a9192b919e2ab9444d93973c4cf8a Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Wed, 21 Jan 2026 17:35:29 +0100
Subject: [PATCH 04/29] chore(biochemestry): port `BiomolPresentInNeighbor` to
 kotlin

---
 .../conditions/BiomolPresentInNeighbor.java   | 99 -------------------
 .../conditions/BiomolPresentInNeighbor.kt     | 90 +++++++++++++++++
 2 files changed, 90 insertions(+), 99 deletions(-)
 delete mode 100644 alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.java
 create mode 100644 alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.kt

diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.java
deleted file mode 100644
index 7e642f9fed..0000000000
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright (C) 2010-2023, Danilo Pianini and contributors
- * listed, for each module, in the respective subproject's build.gradle.kts file.
- *
- * This file is part of Alchemist, and is distributed under the terms of the
- * GNU General Public License, with a linking exception,
- * as described in the file LICENSE in the Alchemist distribution's top directory.
- */
-
-package it.unibo.alchemist.model.biochemistry.conditions;
-
-import it.unibo.alchemist.model.Environment;
-import it.unibo.alchemist.model.Neighborhood;
-import it.unibo.alchemist.model.Node;
-import it.unibo.alchemist.model.Reaction;
-import it.unibo.alchemist.model.biochemistry.CellProperty;
-import it.unibo.alchemist.model.biochemistry.molecules.Biomolecule;
-import it.unibo.alchemist.model.observation.MutableObservable;
-import it.unibo.alchemist.model.observation.Observable;
-import org.apache.commons.math3.util.FastMath;
-
-import java.io.Serial;
-
-import static org.apache.commons.math3.util.CombinatoricsUtils.binomialCoefficientDouble;
-
-/**
- * This condition is valid if a selected biomolecule is present in the neighborhood of the node.
- */
-public final class BiomolPresentInNeighbor extends AbstractNeighborCondition<Double> {
-
-    @Serial
-    private static final long serialVersionUID = 499903479123400111L;
-
-    private final Biomolecule molecule;
-    private final Double concentration;
-
-    /**
-     * @param molecule      the molecule to check
-     * @param concentration the minimum concentration
-     * @param node          the local node
-     * @param environment   the environment
-     */
-    public BiomolPresentInNeighbor(
-        final Environment<Double, ?> environment,
-        final Node<Double> node,
-        final Biomolecule molecule,
-        final Double concentration
-    ) {
-        super(environment, node);
-        declareDependencyOn(molecule);
-        this.molecule = molecule;
-        this.concentration = concentration;
-        setUpObservability();
-    }
-
-    @Override
-    public BiomolPresentInNeighbor cloneCondition(final Node<Double> node, final Reaction<Double> reaction) {
-        return new BiomolPresentInNeighbor(getEnvironment(), node, molecule, concentration);
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    protected Observable<Double> observeNeighborPropensity(final Node<Double> neighbor) {
-        // the neighbor is eligible, its propensity is computed using the concentration of the biomolecule
-        if (neighbor.asPropertyOrNull(CellProperty.class) == null) {
-            return MutableObservable.Companion.observe(0d);
-        }
-        return neighbor.observeConcentration(molecule).map(opt -> opt.map(conc -> {
-            if (conc >= concentration) {
-                return binomialCoefficientDouble(conc.intValue(), (int) FastMath.ceil(concentration));
-            } else {
-                return 0d;
-            }
-        }).fold(() -> 0d, val -> val));
-    }
-
-    @Override
-    public String toString() {
-        return molecule.toString() + " >= " + concentration + " in neighbor";
-    }
-
-    @SuppressWarnings("unchecked")
-    private void setUpObservability() {
-        addObservableDependency(getNode().observeConcentration(molecule));
-        setValidity(
-            observeValidNeighbors().map(validNeighbors -> {
-                if (validNeighbors.isEmpty()) {
-                    return false;
-                }
-                final Neighborhood<Double> neighborhood = getEnvironment().getNeighborhood(getNode());
-                return validNeighbors.entrySet().stream()
-                    .filter(n -> n.getKey().asPropertyOrNull(CellProperty.class) != null)
-                    .allMatch(n ->
-                        neighborhood.contains(n.getKey()) && n.getKey().getConcentration(molecule) >= concentration
-                    );
-            })
-        );
-    }
-}
diff --git a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.kt b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.kt
new file mode 100644
index 0000000000..578c697edf
--- /dev/null
+++ b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.kt
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.biochemistry.conditions
+
+import it.unibo.alchemist.model.Environment
+import it.unibo.alchemist.model.Node
+import it.unibo.alchemist.model.Node.Companion.asPropertyOrNull
+import it.unibo.alchemist.model.Reaction
+import it.unibo.alchemist.model.biochemistry.CellProperty
+import it.unibo.alchemist.model.biochemistry.molecules.Biomolecule
+import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
+import it.unibo.alchemist.model.observation.Observable
+import java.io.Serial
+import org.apache.commons.math3.util.CombinatoricsUtils.binomialCoefficientDouble
+import org.apache.commons.math3.util.FastMath
+
+/**
+ * This condition is valid if a selected biomolecule is present in the neighborhood of the node.
+ *
+ * @param molecule      the molecule to check
+ * @param concentration the minimum concentration
+ * @param node          the local node
+ * @param environment   the environment
+ */
+class BiomolPresentInNeighbor(
+    environment: Environment<Double, *>,
+    node: Node<Double>,
+    private val molecule: Biomolecule,
+    private val concentration: Double,
+) : AbstractNeighborCondition<Double>(environment, node) {
+
+    init {
+        declareDependencyOn(molecule)
+        setUpObservability()
+    }
+
+    protected override fun observeNeighborPropensity(neighbor: Node<Double>): Observable<Double> =
+        neighbor.takeIf { it.asPropertyOrNull<Double, CellProperty<*>>() != null }?.let { n ->
+            // the neighbor is eligible, its propensity is computed using the concentration of the biomolecule
+            n.observeConcentration(molecule).map { maybeValue ->
+                maybeValue.fold(
+                    ifEmpty = { 0.0 },
+                    ifSome = {
+                        if (it >= concentration) {
+                            binomialCoefficientDouble(it.toInt(), FastMath.ceil(concentration).toInt())
+                        } else {
+                            0.0
+                        }
+                    },
+                )
+            }
+        } ?: observe(0.0)
+
+    override fun cloneCondition(
+        newNode: Node<Double>,
+        newReaction: Reaction<Double>,
+    ): AbstractNeighborCondition<Double> = BiomolPresentInNeighbor(environment, node, molecule, concentration)
+
+    override fun toString(): String = "$molecule >= $concentration in neighbor"
+
+    private fun setUpObservability() {
+        addObservableDependency(node.observeConcentration(molecule))
+        setValidity(
+            observeValidNeighbors().map { validNeighbors ->
+                val current = environment.getNeighborhood(node).current
+                validNeighbors
+                    ?.takeIf { it.isNotEmpty() }?.entries
+                    ?.filter { it.key.asPropertyOrNull<Double, CellProperty<*>>() != null }
+                    ?.all { it.key in current && it.key.getConcentration(molecule) >= concentration }
+                    ?: false
+            },
+        )
+    }
+
+    /**
+     * Companion object for the [BiomolPresentInNeighbor] class.
+     *
+     * This object stores the `serialVersionUID` constant required for serialization purposes.
+     */
+    companion object {
+        @Serial const val serialVersionUID: Long = 499903479123400111L
+    }
+}

From 29fca7361b4b3b7480d1e54316b66463b20ebb7e Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Wed, 21 Jan 2026 17:58:44 +0100
Subject: [PATCH 05/29] feat!: fully transition to observable neighborhoods

---
 .../it/unibo/alchemist/model/Environment.kt       |  7 +------
 .../model/observation/DerivedObservable.kt        |  8 +++++---
 .../main/kotlin/it/unibo/alchemist/core/Engine.kt |  6 +++---
 .../alchemist/core/JGraphTDependencyGraph.kt      |  2 +-
 .../model/surrogates/EnvironmentSurrogate.kt      |  2 +-
 .../schema/model/EnvironmentSurrogateTest.kt      |  2 +-
 .../model/conditions/NeighborHasConcentration.kt  |  2 +-
 .../model/environments/AbstractEnvironment.kt     | 12 ++++++------
 .../model/linkingrules/ConnectViaAccessPoint.kt   |  3 ++-
 .../timedistributions/SimpleNetworkArrivals.kt    |  2 +-
 .../it/unibo/alchemist/util/Environments.kt       |  4 ++--
 .../TestSimpleNetworkArrivals.kt                  | 10 ++++------
 .../actions/AbstractNeighborAction.java           |  8 +++-----
 .../actions/ChangeBiomolConcentrationInEnv.java   |  2 +-
 .../actions/ChemotacticPolarization.java          | 13 ++++++++++---
 .../conditions/AbstractNeighborCondition.java     |  4 ++--
 .../conditions/BiomolPresentInEnv.java            |  2 +-
 .../model/biochemistry/conditions/EnvPresent.java |  4 ++--
 .../conditions/NeighborhoodPresent.java           |  2 +-
 .../environments/BioRect2DEnvironment.java        |  2 +-
 .../ChangeBiomolConcentrationInNeighbor.kt        | 15 ++++++++-------
 .../TestMoleculeSwapWithinNeighborhood.kt         |  4 ++--
 .../TestNeighborhoodReactionsPropensities.kt      |  2 +-
 .../model/protelis/AlchemistNetworkManager.kt     | 13 ++++++-------
 .../actions/AbstractSAPEREMoveNodeAgent.java      |  4 ++--
 .../actions/AbstractSAPERENeighborAgent.java      |  4 ++--
 .../sapere/actions/LsaAscendingGradientDist.java  | 10 ++++++----
 .../sapere/actions/LsaCountNeighborsAction.java   |  2 +-
 .../sapere/actions/LsaRandomNeighborAction.java   |  2 +-
 .../sapere/actions/SAPEREWalkerRiseGradient.java  |  2 +-
 .../conditions/LsaNeighborhoodCondition.java      |  2 +-
 .../model/sapere/reactions/SAPEREGradient.java    |  2 +-
 .../model/sapere/reactions/SAPEREReaction.java    |  2 +-
 .../model/scafi/actions/SendScafiMessage.scala    |  9 ++++++++-
 .../alchemist/boundary/extractors/NodeDegree.kt   |  2 +-
 .../it/unibo/alchemist/test/TestGraphStream.kt    |  4 ++--
 .../test/TestGraphStreamReproducibility.kt        |  2 +-
 .../maps/linkingrules/TestInSightConnection.kt    |  2 +-
 .../swingui/monitor/impl/Generic2DDisplay.java    |  2 +-
 39 files changed, 96 insertions(+), 86 deletions(-)

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
index b4159d7311..5aff97c1ee 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
@@ -93,16 +93,11 @@ interface Environment<T, P : Position<out P>> :
      */
     var linkingRule: LinkingRule<T, P>
 
-    /**
-     * Given a [node], this method returns its neighborhood.
-     */
-    fun getNeighborhood(node: Node<T>): Neighborhood<T>
-
     /**
      * Given a [node], this method returns an observable view of
      * its neighborhood.
      */
-    fun observeNeighborhood(node: Node<T>): Observable<Neighborhood<T>>
+    fun getNeighborhood(node: Node<T>): Observable<Neighborhood<T>>
 
     /**
      * Allows accessing a [Node] in this [Environment] known its [id].
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
index 8dabb068de..0fb63697bd 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
@@ -47,17 +47,19 @@ abstract class DerivedObservable<T>(private val emitOnDistinct: Boolean = true)
             }
         }
 
-    override fun onChange(registrant: Any, callback: (T) -> Unit) {
+    override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (T) -> Unit) {
         val wasEmpty = callbacks.isEmpty()
         callbacks[registrant] = callbacks[registrant].orEmpty() + callback
         if (wasEmpty) {
             val initial = computeFresh()
             cached = initial.some()
-            callback(initial)
+            if (invokeOnRegistration) {
+                callback(initial)
+            }
 
             isListening = true
             startMonitoring()
-        } else {
+        } else if (invokeOnRegistration) {
             callback(current)
         }
     }
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
index 42a01a4a5e..164d314379 100644
--- a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
+++ b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
@@ -225,7 +225,7 @@ open class Engine<T, P : Position<out P>>(
      */
     private inner class Movement(private val sourceNode: Node<T>) : Update() {
         override val reactionsToUpdate: Sequence<Actionable<T>>
-            get() = getReactionsRelatedTo(sourceNode, environment.getNeighborhood(sourceNode)).filter {
+            get() = getReactionsRelatedTo(sourceNode, environment.getNeighborhood(sourceNode).current).filter {
                 it.inboundDependencies.any { dependency -> dependency.dependsOn(Dependency.MOVEMENT) }
             }
 
@@ -292,8 +292,8 @@ open class Engine<T, P : Position<out P>>(
         override val reactionsToUpdate: Sequence<Actionable<T>>
             get() {
                 val subjects = sequenceOf(sourceNode, targetNode)
-                val sourceNeighbors = environment.getNeighborhood(sourceNode).asSequence()
-                val targetNeighbors = environment.getNeighborhood(targetNode).asSequence()
+                val sourceNeighbors = environment.getNeighborhood(sourceNode).current.asSequence()
+                val targetNeighbors = environment.getNeighborhood(targetNode).current.asSequence()
                 val allSubjects = (subjects + sourceNeighbors + targetNeighbors).distinct()
                 return allSubjects.flatMap { it.reactions.asSequence() }.filter {
                     it.inputContext ==
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/JGraphTDependencyGraph.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/JGraphTDependencyGraph.kt
index 7886912e43..8814993771 100644
--- a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/JGraphTDependencyGraph.kt
+++ b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/JGraphTDependencyGraph.kt
@@ -239,7 +239,7 @@ class JGraphTDependencyGraph<T>(private val environment: Environment<T, *>) : De
         }
     }
 
-    private val Node<T>.neighborhood get() = environment.getNeighborhood(this).neighbors
+    private val Node<T>.neighborhood get() = environment.getNeighborhood(this).current.neighbors
 
     private companion object {
         private val Actionable<*>.inputContext get() =
diff --git a/alchemist-graphql-surrogates/src/main/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/surrogates/EnvironmentSurrogate.kt b/alchemist-graphql-surrogates/src/main/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/surrogates/EnvironmentSurrogate.kt
index 9df5c84dfd..6596954292 100644
--- a/alchemist-graphql-surrogates/src/main/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/surrogates/EnvironmentSurrogate.kt
+++ b/alchemist-graphql-surrogates/src/main/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/surrogates/EnvironmentSurrogate.kt
@@ -82,7 +82,7 @@ data class EnvironmentSurrogate<T, P : Position<out P>>(
      */
     @GraphQLDescription("The neighborhood of the node with the given id")
     fun getNeighborhood(nodeId: Int): NeighborhoodSurrogate<T> =
-        origin.getNeighborhood(origin.getNodeByID(nodeId)).toGraphQLNeighborhoodSurrogate()
+        origin.getNeighborhood(origin.getNodeByID(nodeId)).current.toGraphQLNeighborhoodSurrogate()
 
     /**
      * Clone the node associated with the given id to the specified position.
diff --git a/alchemist-graphql/src/jvmTest/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/EnvironmentSurrogateTest.kt b/alchemist-graphql/src/jvmTest/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/EnvironmentSurrogateTest.kt
index ce3d4f4211..d0c2a80c8a 100644
--- a/alchemist-graphql/src/jvmTest/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/EnvironmentSurrogateTest.kt
+++ b/alchemist-graphql/src/jvmTest/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/EnvironmentSurrogateTest.kt
@@ -38,7 +38,7 @@ class EnvironmentSurrogateTest<T, P> where T : Any, P : Position<P>, P : Vector<
                 val nodeSurrogate = envSurrogate.nodeById(node.id)
                 checkNodeSurrogate(node, nodeSurrogate)
                 checkPositionSurrogate(envWrapper.getPosition(node), envSurrogate.nodeToPos()[node.id]!!)
-                checkNeighborhood(envWrapper.getNeighborhood(node), envSurrogate.getNeighborhood(node.id))
+                checkNeighborhood(envWrapper.getNeighborhood(node).current, envSurrogate.getNeighborhood(node.id))
             }
             // Test propagation of changes
             val newNode = envWrapper.nodes.first().cloneNode(Time.ZERO)
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NeighborHasConcentration.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NeighborHasConcentration.kt
index fef40f5e25..572685eae8 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NeighborHasConcentration.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/NeighborHasConcentration.kt
@@ -38,7 +38,7 @@ class NeighborHasConcentration<T>(
 
     init {
         setValidity(
-            environment.observeNeighborhood(node).switchMap { neighborhood ->
+            environment.getNeighborhood(node).switchMap { neighborhood ->
                 neighborhood.neighbors.map { it.observeConcentration(target) }
                     .combineLatest { neighborsConcentrations ->
                         neighborsConcentrations.any { it.isSome { nConc -> nConc == concentration } }
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
index d8ea597236..9e65e10336 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
@@ -154,7 +154,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
             spatialIndex.insert(node, *actualPosition.coordinates)
             updateNeighborhood(node, true)
             ifEngineAvailable { it.nodeAdded(node) }
-            nodeAdded(node, position, getNeighborhood(node))
+            nodeAdded(node, position, retrieveNeighborhood(node))
             true
         }
         else -> false
@@ -192,7 +192,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
     ): Sequence<Operation<T>> = newNeighborhood
         .getNeighbors()
         .asSequence()
-        .filterNot { it in (oldNeighborhood ?: emptySet()) || getNeighborhood(it).contains(center) }
+        .filterNot { it in (oldNeighborhood ?: emptySet()) || retrieveNeighborhood(it).contains(center) }
         .map { Operation(center, it, true) }
 
     private fun getAllNodesInRange(center: P, range: Double): List<Node<T>> {
@@ -257,7 +257,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
 
     override fun getLayer(molecule: Molecule): Layer<T, P>? = layers[molecule]
 
-    override fun getNeighborhood(node: Node<T>): Neighborhood<T> {
+    protected fun retrieveNeighborhood(node: Node<T>): Neighborhood<T> {
         val result = neighCache[node.id]
         requireNotNull(result) {
             check(!nodes.contains(node)) {
@@ -268,7 +268,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         return result
     }
 
-    override fun observeNeighborhood(node: Node<T>): Observable<Neighborhood<T>> =
+    override fun getNeighborhood(node: Node<T>): Observable<Neighborhood<T>> =
         observableNeighCache[node.id].map { maybeNeighborhood ->
             val neighborhood = maybeNeighborhood.getOrNull()
             requireNotNull(neighborhood) {
@@ -359,7 +359,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
     ): Sequence<Operation<T>> = oldNeighborhood
         ?.neighbors
         ?.asSequence()
-        ?.filter { neigh -> !newNeighborhood.contains(neigh) && getNeighborhood(neigh).contains(center) }
+        ?.filter { neigh -> !newNeighborhood.contains(neigh) && retrieveNeighborhood(neigh).contains(center) }
         ?.map { neigh -> Operation(center, neigh, isAdd = false) }
         .orEmpty()
 
@@ -526,7 +526,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
                     .getNeighbors()
                     .asSequence()
                     .filterNot(newNeighborhood::contains)
-                    .map(this::getNeighborhood)
+                    .map(this::retrieveNeighborhood)
                     .filter { neigh -> neigh.contains(node) }
                     .forEach { neighborhoodToChange ->
                         val formerNeighbor = neighborhoodToChange.getCenter()
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/linkingrules/ConnectViaAccessPoint.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/linkingrules/ConnectViaAccessPoint.kt
index cbe49f591a..072f2cc4d7 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/linkingrules/ConnectViaAccessPoint.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/linkingrules/ConnectViaAccessPoint.kt
@@ -41,7 +41,8 @@ class ConnectViaAccessPoint<T, P : Position<P>>(radius: Double, val accessPointI
                         environment,
                         center,
                         neighbors.filter {
-                            it == closestAP || !it.isAccessPoint && environment.getNeighborhood(it).contains(closestAP)
+                            it == closestAP ||
+                                !it.isAccessPoint && environment.getNeighborhood(it).current.contains(closestAP)
                         },
                     )
                 } ?: Neighborhoods.make(environment, center, emptyList())
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/timedistributions/SimpleNetworkArrivals.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/timedistributions/SimpleNetworkArrivals.kt
index 776b7f4462..bf2f60b267 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/timedistributions/SimpleNetworkArrivals.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/timedistributions/SimpleNetworkArrivals.kt
@@ -143,7 +143,7 @@ class SimpleNetworkArrivals<T> private constructor(
 
     /** Gets the neighbors of a node as a collection. */
     val Node<T>.neighborhood: Collection<Node<T>>
-        get() = environment.getNeighborhood(this).neighbors
+        get() = environment.getNeighborhood(this).current.neighbors
 
     /** Computes the effective bandwidth considering access point load balancing. */
     val bandwidth: Double
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/util/Environments.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/util/Environments.kt
index 459f87f4a6..e1cf356288 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/util/Environments.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/util/Environments.kt
@@ -28,7 +28,7 @@ object Environments {
     ): (Node<T>, Node<T>) -> Double = { n1, n2 ->
         when {
             n1 == n2 -> 0.0
-            n2 in getNeighborhood(n1) -> computeDistance(n1, n2)
+            n2 in getNeighborhood(n1).current -> computeDistance(n1, n2)
             else -> POSITIVE_INFINITY
         }
     }
@@ -156,7 +156,7 @@ object Environments {
         while (toExplore.isNotEmpty()) {
             val current = toExplore.first()
             explored += current
-            val neighbors = getNeighborhood(current).toMutableSet()
+            val neighbors = getNeighborhood(current).current.toMutableSet()
             toExplore += neighbors
             toExplore -= explored
         }
diff --git a/alchemist-implementationbase/src/test/kotlin/it/unibo/alchemist/model/timedistributions/TestSimpleNetworkArrivals.kt b/alchemist-implementationbase/src/test/kotlin/it/unibo/alchemist/model/timedistributions/TestSimpleNetworkArrivals.kt
index ad26be25d7..4557cee825 100644
--- a/alchemist-implementationbase/src/test/kotlin/it/unibo/alchemist/model/timedistributions/TestSimpleNetworkArrivals.kt
+++ b/alchemist-implementationbase/src/test/kotlin/it/unibo/alchemist/model/timedistributions/TestSimpleNetworkArrivals.kt
@@ -13,13 +13,11 @@ import io.mockk.every
 import io.mockk.mockk
 import it.unibo.alchemist.model.Environment
 import it.unibo.alchemist.model.Incarnation
-import it.unibo.alchemist.model.Molecule
 import it.unibo.alchemist.model.Node
 import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.positions.Euclidean2DPosition
 import kotlin.test.assertEquals
 import kotlin.test.assertNotEquals
-import org.danilopianini.util.ListSet
 import org.danilopianini.util.ListSets
 import org.junit.jupiter.api.Test
 
@@ -33,7 +31,7 @@ class TestSimpleNetworkArrivals {
         val incarnation = mockk<Incarnation<Any, Euclidean2DPosition>>()
         val environment = mockk<Environment<Any, Euclidean2DPosition>>()
         val node = mockk<Node<Any>>()
-        every { environment.getNeighborhood(node).neighbors } returns ListSets.emptyListSet()
+        every { environment.getNeighborhood(node).current.neighbors } returns ListSets.emptyListSet()
         val propagationDelay = 0.1
         val packetSize = 1000.0
         val bandwidth = 1000.0
@@ -56,8 +54,8 @@ class TestSimpleNetworkArrivals {
         val environment = mockk<Environment<Any, Euclidean2DPosition>>()
         val node1 = mockk<Node<Any>>()
         val node2 = mockk<Node<Any>>()
-        every { environment.getNeighborhood(node1).neighbors } returns ListSets.emptyListSet()
-        every { environment.getNeighborhood(node2).neighbors } returns ListSets.emptyListSet()
+        every { environment.getNeighborhood(node1).current.neighbors } returns ListSets.emptyListSet()
+        every { environment.getNeighborhood(node2).current.neighbors } returns ListSets.emptyListSet()
         val distribution = SimpleNetworkArrivals(
             incarnation = incarnation,
             node = node1,
@@ -79,7 +77,7 @@ class TestSimpleNetworkArrivals {
         val incarnation = mockk<Incarnation<Any, Euclidean2DPosition>>()
         val environment = mockk<Environment<Any, Euclidean2DPosition>>()
         val node = mockk<Node<Any>>()
-        every { environment.getNeighborhood(node).neighbors } returns ListSets.emptyListSet()
+        every { environment.getNeighborhood(node).current.neighbors } returns ListSets.emptyListSet()
         val distribution = SimpleNetworkArrivals(
             incarnation = incarnation,
             node = node,
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/AbstractNeighborAction.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/AbstractNeighborAction.java
index e118931909..070c1b299b 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/AbstractNeighborAction.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/AbstractNeighborAction.java
@@ -29,7 +29,6 @@ public abstract class AbstractNeighborAction<T> extends AbstractRandomizableActi
     @Serial
     private static final long serialVersionUID = -2287346030993830896L;
     private final Environment<T, ?> environment;
-    private final Node<T> node;
 
     /**
      * @param node the current node
@@ -42,7 +41,6 @@ protected AbstractNeighborAction(
             final RandomGenerator randomGenerator
     ) {
         super(node, randomGenerator);
-        this.node = node;
         this.environment = environment;
     }
 
@@ -54,9 +52,9 @@ protected AbstractNeighborAction(
      */
     @Override
     public void execute() {
-        final Neighborhood<T> neighborhood = environment.getNeighborhood(node);
-        if (!neighborhood.isEmpty()) {
-            execute(Iterables.INSTANCE.randomElement(neighborhood, getRandomGenerator()));
+        final Neighborhood<T> currentNeighborhood = getEnvironment().getNeighborhood(getNode()).getCurrent();
+        if (!currentNeighborhood.isEmpty()) {
+            execute(Iterables.INSTANCE.randomElement(currentNeighborhood, getRandomGenerator()));
         }
     }
 
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChangeBiomolConcentrationInEnv.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChangeBiomolConcentrationInEnv.java
index 33e39673e6..8d08ed5c22 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChangeBiomolConcentrationInEnv.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChangeBiomolConcentrationInEnv.java
@@ -138,7 +138,7 @@ public Context getContext() {
      * @return a list containing the environment nodes around
      */
     private List<EnvironmentNode> getEnvironmentNodesSurrounding() {
-        return environment.getNeighborhood(getNode()).getNeighbors().stream()
+        return environment.getNeighborhood(getNode()).getCurrent().getNeighbors().stream()
                 .parallel()
                 .flatMap(n -> n instanceof EnvironmentNode ? Stream.of((EnvironmentNode) n) : Stream.empty())
                 .collect(Collectors.toList());
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChemotacticPolarization.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChemotacticPolarization.java
index ee76392cf3..f64f090b6c 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChemotacticPolarization.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChemotacticPolarization.java
@@ -22,6 +22,7 @@
 import org.apache.commons.math3.util.FastMath;
 
 import java.io.Serial;
+import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
@@ -38,6 +39,7 @@ public final class ChemotacticPolarization extends AbstractAction<Double> {
     private final Biomolecule biomolecule;
     private final boolean ascend;
     private final CellProperty<Euclidean2DPosition> cell;
+    private List<Node<Double>> neighbors = new ArrayList<>(0);
 
     /**
      * @param environment the environment
@@ -67,6 +69,13 @@ public ChemotacticPolarization(
         } else {
             throw new IllegalArgumentException("Possible imput string are only up or down");
         }
+
+        environment.getNeighborhood(getNode()).onChange(this, neighborhood -> {
+            this.neighbors = neighborhood.getNeighbors().stream()
+                .filter(n -> n instanceof EnvironmentNode && n.contains(this.biomolecule))
+                .collect(Collectors.toList());
+            return null;
+        });
     }
 
     /**
@@ -98,9 +107,7 @@ public ChemotacticPolarization cloneAction(final Node<Double> node, final Reacti
     public void execute() {
         // declaring a variable for the node where this action is set, to have faster access
         final Node<Double> thisNode = getNode();
-        final List<Node<Double>> l = environment.getNeighborhood(thisNode).getNeighbors().stream()
-                .filter(n -> n instanceof EnvironmentNode && n.contains(biomolecule))
-                .collect(Collectors.toList());
+        final List<Node<Double>> l = this.neighbors;
         if (l.isEmpty()) {
             cell.addPolarizationVersor(Euclidean2DPosition.Companion.getZero());
         } else {
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/AbstractNeighborCondition.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/AbstractNeighborCondition.java
index 926d08cb01..73a4347a56 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/AbstractNeighborCondition.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/AbstractNeighborCondition.java
@@ -45,7 +45,7 @@ public abstract class AbstractNeighborCondition<T> extends AbstractCondition<T>
     protected AbstractNeighborCondition(final Environment<T, ?> environment, final Node<T> node) {
         super(node);
         this.environment = environment;
-        addObservableDependency(getEnvironment().observeNeighborhood(getNode()));
+        addObservableDependency(getEnvironment().getNeighborhood(getNode()));
         setPropensityContributionObservable();
     }
 
@@ -98,7 +98,7 @@ public final Map<Node<T>, Double> getValidNeighbors() {
      */
     public final Observable<Map<Node<T>, Double>> observeValidNeighbors() {
         return ObservableExtensions.INSTANCE.switchMap(
-            getEnvironment().observeNeighborhood(getNode()),
+            getEnvironment().getNeighborhood(getNode()),
             neighborhood -> {
                 final List<Observable<Pair<Node<T>, Double>>> propensities = neighborhood.getNeighbors().stream()
                     .map((Node<T> neighbor) -> observeNeighborPropensity(neighbor)
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java
index 2f582029c9..8b5b488a94 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java
@@ -84,7 +84,7 @@ private void setUpObservability() {
     }
 
     private Observable<Double> observeTotalQuantity() {
-        return environment.observeNeighborhood(getNode()).mergeWith(
+        return environment.getNeighborhood(getNode()).mergeWith(
             environment.observePosition(getNode()),
             (neighborhood, position) -> {
                 final double quantityInEnvNodes = neighborhood.getNeighbors().stream()
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/EnvPresent.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/EnvPresent.java
index 413cfff457..1701191f5b 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/EnvPresent.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/EnvPresent.java
@@ -39,8 +39,8 @@ public EnvPresent(final Environment<Double, ?> environment, final Node<Double> n
         super(node);
         this.environment = environment;
 
-        addObservableDependency(environment.observeNeighborhood(node));
-        setValidity(environment.observeNeighborhood(node).map(it ->
+        addObservableDependency(environment.getNeighborhood(node));
+        setValidity(environment.getNeighborhood(node).map(it ->
             it.getNeighbors().stream().anyMatch(n -> n instanceof EnvironmentNode)
         ));
 
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/NeighborhoodPresent.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/NeighborhoodPresent.java
index 71eac51956..8c1d504627 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/NeighborhoodPresent.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/NeighborhoodPresent.java
@@ -39,7 +39,7 @@ public final class NeighborhoodPresent<T> extends AbstractNeighborCondition<T> {
     public NeighborhoodPresent(final Environment<T, ?> environment, final Node<T> node) {
         super(environment, node);
 
-        setValidity(environment.observeNeighborhood(getNode()).map(neighborhood ->
+        setValidity(environment.getNeighborhood(getNode()).map(neighborhood ->
             neighborhood.getNeighbors().stream()
                 .anyMatch(n -> n.asPropertyOrNull(CellProperty.class) != null)
             ));
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironment.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironment.java
index fa655585e0..66de776bb1 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironment.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironment.java
@@ -112,7 +112,7 @@ protected final boolean isAllowed(final Euclidean2DPosition p) {
     public final void moveNode(final Node<Double> node, @Nonnull final Euclidean2DPosition direction) {
         if (node.asPropertyOrNull(CellProperty.class) != null) {
             super.moveNode(node, direction);
-            final Neighborhood<Double> neigh = getNeighborhood(node);
+            final Neighborhood<Double> neigh = retrieveNeighborhood(node);
             final Map<Junction, Map<Node<Double>, Integer>> jun = node
                     .asProperty(CellProperty.class).getJunctions().getCurrent();
             jun.forEach((key, value) -> value.forEach((key1, value1) -> {
diff --git a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/actions/ChangeBiomolConcentrationInNeighbor.kt b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/actions/ChangeBiomolConcentrationInNeighbor.kt
index d1b23dbd9d..491e98a3e9 100644
--- a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/actions/ChangeBiomolConcentrationInNeighbor.kt
+++ b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/actions/ChangeBiomolConcentrationInNeighbor.kt
@@ -30,17 +30,18 @@ class ChangeBiomolConcentrationInNeighbor(
     val molecule: Biomolecule,
     val deltaConcentration: Double,
 ) : AbstractNeighborAction<Double>(node, environment, randomGenerator) {
+
     override fun cloneAction(newNode: Node<Double>, newReaction: Reaction<Double>) =
         ChangeBiomolConcentrationInNeighbor(randomGenerator, environment, newNode, molecule, deltaConcentration)
 
     override fun execute() {
-        val neighborhood = environment.getNeighborhood(node)
-        val validNeighbors =
-            neighborhood.filter {
-                it.asPropertyOrNull<Double, CellProperty<Euclidean2DPosition>>() != null &&
-                    (deltaConcentration > 0 || it.getConcentration(molecule) >= deltaConcentration)
-            }
-        execute(validNeighbors.randomElement(randomGenerator))
+        val validNeighbors = environment.getNeighborhood(node).current.filter {
+            it.asPropertyOrNull<Double, CellProperty<Euclidean2DPosition>>() != null &&
+                (deltaConcentration > 0 || it.getConcentration(molecule) >= deltaConcentration)
+        }
+        if (validNeighbors.isNotEmpty()) {
+            execute(validNeighbors.randomElement(randomGenerator))
+        }
     }
 
     override fun execute(targetNode: Node<Double>) {
diff --git a/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/molecules/TestMoleculeSwapWithinNeighborhood.kt b/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/molecules/TestMoleculeSwapWithinNeighborhood.kt
index aa8ab50e06..34ab815822 100644
--- a/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/molecules/TestMoleculeSwapWithinNeighborhood.kt
+++ b/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/molecules/TestMoleculeSwapWithinNeighborhood.kt
@@ -48,8 +48,8 @@ class TestMoleculeSwapWithinNeighborhood {
         environment.linkingRule = LINKING_RULE
         environment.addNode(nodes.first, INITIAL_POSITIONS.first)
         environment.addNode(nodes.second, INITIAL_POSITIONS.second)
-        assertTrue(environment.getNeighborhood(nodes.first).neighbors.contains(nodes.second))
-        assertTrue(environment.getNeighborhood(nodes.second).neighbors.contains(nodes.first))
+        assertTrue(environment.getNeighborhood(nodes.first).current.neighbors.contains(nodes.second))
+        assertTrue(environment.getNeighborhood(nodes.second).current.neighbors.contains(nodes.first))
         nodes.first.setConcentration(BIOMOLECULE, 1.0)
     }
 
diff --git a/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/reactions/TestNeighborhoodReactionsPropensities.kt b/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/reactions/TestNeighborhoodReactionsPropensities.kt
index 5d5570dc52..eb364c17a3 100644
--- a/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/reactions/TestNeighborhoodReactionsPropensities.kt
+++ b/alchemist-incarnation-biochemistry/src/test/kotlin/it/unibo/alchemist/model/biochemistry/reactions/TestNeighborhoodReactionsPropensities.kt
@@ -68,7 +68,7 @@ class TestNeighborhoodReactionsPropensities {
                 .onEach { it.second.setConcentration(BIOMOLECULE, it.first) }
                 .map { it.second }
                 .onEach { environment.addNode(it, POSITION) }
-        assertEquals(neighbors.toList(), environment.getNeighborhood(centralNode).neighbors.toList())
+        assertEquals(neighbors.toList(), environment.getNeighborhood(centralNode).current.neighbors.toList())
     }
 
     @Test
diff --git a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/AlchemistNetworkManager.kt b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/AlchemistNetworkManager.kt
index 6a5265160b..f7c67e302e 100644
--- a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/AlchemistNetworkManager.kt
+++ b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/AlchemistNetworkManager.kt
@@ -58,6 +58,10 @@ class AlchemistNetworkManager @JvmOverloads constructor(
     private var toBeSent: Map<CodePath, Any> = emptyMap()
     private var neighborState = ImmutableMap.of<DeviceUID, Map<CodePath, Any>>()
     private var timeAtLastValidityCheck = Double.NEGATIVE_INFINITY
+    private val neighborDevices: Set<ProtelisDevice<*>>
+        get() = environment.getNeighborhood(device.node).current.neighbors
+            .mapNotNull { it.asPropertyOrNull<Any, ProtelisDevice<*>>() }
+            .toSet()
 
     init {
         require(retentionTime.isNaN() || retentionTime >= 0) { "The retention time can't be negative." }
@@ -75,11 +79,7 @@ class AlchemistNetworkManager @JvmOverloads constructor(
                 val stateBuilder = ImmutableMap.builder<DeviceUID, Map<CodePath, Any>>()
                 val messagesIterator = messages.values.iterator()
                 val retainsNeighbors = retentionTime.isNaN()
-                val neighbors: Set<DeviceUID> = emptySet<DeviceUID>().takeUnless { retainsNeighbors }
-                    ?: environment.getNeighborhood(device.node)
-                        .neighbors
-                        .mapNotNull { it.asPropertyOrNull<Any, ProtelisDevice<*>>() }
-                        .toSet()
+                val neighbors: Set<DeviceUID> = emptySet<DeviceUID>().takeUnless { retainsNeighbors } ?: neighborDevices
                 while (messagesIterator.hasNext()) {
                     val message = messagesIterator.next()
                     val messageIsValid =
@@ -119,8 +119,7 @@ class AlchemistNetworkManager @JvmOverloads constructor(
     fun simulateMessageArrival(currentTime: Double) {
         if (toBeSent.isNotEmpty()) {
             val msg = MessageInfo(currentTime, device, toBeSent)
-            environment.getNeighborhood(device.node)
-                .mapNotNull { it.asPropertyOrNull<Any, ProtelisDevice<*>>() }
+            neighborDevices
                 .forEach { neighborDevice ->
                     val destination = neighborDevice.getNetworkManager(program)
                     var packetArrives = true
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPEREMoveNodeAgent.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPEREMoveNodeAgent.java
index 6d7dec1993..dbc2fa2344 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPEREMoveNodeAgent.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPEREMoveNodeAgent.java
@@ -93,14 +93,14 @@ protected final P getPosition(final Node<List<ILsaMolecule>> node) {
      * @return the position of node
      */
     protected final Neighborhood<List<ILsaMolecule>> getNeighborhood(final ILsaNode node) {
-        return environment.getNeighborhood(node);
+        return environment.getNeighborhood(node).getCurrent();
     }
 
     /**
      * @return the position of node
      */
     protected final Neighborhood<List<ILsaMolecule>> getLocalNeighborhood() {
-        return environment.getNeighborhood(getNode());
+        return environment.getNeighborhood(getNode()).getCurrent();
     }
 
     /**
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPERENeighborAgent.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPERENeighborAgent.java
index 1e67e749d9..2aec35ab52 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPERENeighborAgent.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPERENeighborAgent.java
@@ -134,14 +134,14 @@ protected final P getPosition(final ILsaNode node) {
      * @return the position of node
      */
     protected final Neighborhood<List<ILsaMolecule>> getNeighborhood(final ILsaNode node) {
-        return environment.getNeighborhood(node);
+        return environment.getNeighborhood(node).getCurrent();
     }
 
     /**
      * @return the position of node
      */
     protected final Neighborhood<List<ILsaMolecule>> getLocalNeighborhood() {
-        return environment.getNeighborhood(getNode());
+        return environment.getNeighborhood(getNode()).getCurrent();
     }
 
     /**
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaAscendingGradientDist.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaAscendingGradientDist.java
index 7f3d06d744..3b88488ab5 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaAscendingGradientDist.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaAscendingGradientDist.java
@@ -36,7 +36,7 @@ public final class LsaAscendingGradientDist<P extends Position<P>> extends Abstr
     private static final ILsaMolecule MOLGRAD = new LsaMolecule("grad, req, Type, Distance, Time");
     private static final ILsaMolecule MOLRESPONSE = new LsaMolecule("response, Req, Ser, MD, D");
     private static final int POS = 3;
-    private final Environment<List<ILsaMolecule>, ?> environment;
+    private Neighborhood<List<ILsaMolecule>> neigh;
 
     /**
      * @param environment environment
@@ -44,15 +44,17 @@ public final class LsaAscendingGradientDist<P extends Position<P>> extends Abstr
      */
     public LsaAscendingGradientDist(final Environment<List<ILsaMolecule>, P> environment, final ILsaNode node) {
         super(environment, node, MOLRESPONSE);
-        this.environment = environment;
+        environment.getNeighborhood(node).onChange(this, neighborhood -> {
+            this.neigh = neighborhood;
+            return null;
+        });
     }
 
     @Override
     public void execute() {
         double minGrad = getLSAArgumentAsDouble(getNode().getConcentration(MOLGRAD).get(0), POS);
-        final Neighborhood<List<ILsaMolecule>> neigh = environment.getNeighborhood(getNode());
         final List<LsaNode> targetPositions = new ArrayList<>();
-        for (final Node<List<ILsaMolecule>> node : neigh.getNeighbors()) {
+        for (final Node<List<ILsaMolecule>> node : this.neigh.getNeighbors()) {
             final LsaNode n = (LsaNode) node;
             final List<ILsaMolecule> gradList;
             gradList = n.getConcentration(MOLGRAD);
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaCountNeighborsAction.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaCountNeighborsAction.java
index 6f10c04b55..f6c06631c3 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaCountNeighborsAction.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaCountNeighborsAction.java
@@ -116,7 +116,7 @@ public void execute() {
         final List<IExpression> l = mol.allocateVar(getMatches());
         Double num = 0.0;
         environment.getNeighborhood(getNode());
-        for (final Node<List<ILsaMolecule>> nod : environment.getNeighborhood(getNode()).getNeighbors()) {
+        for (final Node<List<ILsaMolecule>> nod : environment.getNeighborhood(getNode()).getCurrent().getNeighbors()) {
             if (!nod.getConcentration(new LsaMolecule(l)).isEmpty()) {
                 num++;
             }
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaRandomNeighborAction.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaRandomNeighborAction.java
index 0f5bddfc85..d3cd0cfbb8 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaRandomNeighborAction.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/LsaRandomNeighborAction.java
@@ -172,7 +172,7 @@ protected void setSynthectics(final ILsaNode node) {
          * #NEIGH
          */
         if (initNeigh) {
-            setSyntheticNeigh(environment.getNeighborhood(node).getNeighbors());
+            setSyntheticNeigh(environment.getNeighborhood(node).getCurrent().getNeighbors());
         }
         /*
          * #O
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/SAPEREWalkerRiseGradient.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/SAPEREWalkerRiseGradient.java
index cb25e31bc4..e7faa13f5f 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/SAPEREWalkerRiseGradient.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/SAPEREWalkerRiseGradient.java
@@ -162,7 +162,7 @@ public GeoPosition getTarget() {
             final Position<?> curNodeActualPos = environment.getPosition(curNode);
             if (curNode.equals(node)
                 || !curPos.equals(curNodeActualPos)
-                || environment.getNeighborhood(node).contains(curNode)) {
+                || environment.getNeighborhood(node).getCurrent().contains(curNode)) {
                 /*
                  * Update target
                  */
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
index 7469dac091..843af6d080 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
@@ -56,7 +56,7 @@ public LsaNeighborhoodCondition(
         // every time a change in node's neighborhood is emitted, or one of the
         // members' LSA space has changed.
         addObservableDependency(ObservableExtensions.INSTANCE.switchMap(
-            environment.observeNeighborhood(node).map(Neighborhood::getNeighbors),
+            environment.getNeighborhood(node).map(Neighborhood::getNeighbors),
             neighbors ->
                 ObservableExtensions.INSTANCE.combineLatest(
                     neighbors.stream()
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
index ce103a5c14..a838602775 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
@@ -394,7 +394,7 @@ protected void updateInternalStatus(
         final P curPos = this.environment.getPosition(getNode());
         final boolean positionChanged = !curPos.equals(mypos);
         boolean neighPositionChanged = false;
-        for (final Node<List<ILsaMolecule>> n : this.environment.getNeighborhood(getNode())) {
+        for (final Node<List<ILsaMolecule>> n : this.environment.getNeighborhood(getNode()).getCurrent()) {
             final P p = this.environment.getPosition(n);
             final int nid = n.getId();
             positionCacheTemp.put(nid, p);
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java
index 958ea19215..38cf2023d6 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java
@@ -240,7 +240,7 @@ protected void updateInternalStatus(
              * Valid nodes must be re-initialized, as per issue #
              */
             final Collection<? extends Node<List<ILsaMolecule>>> neighs =
-                    this.environment.getNeighborhood(getNode()).getNeighbors();
+                    this.environment.getNeighborhood(getNode()).getCurrent().getNeighbors();
             validNodes = new ArrayList<>(neighs.size());
             for (final Node<List<ILsaMolecule>> neigh: neighs) {
                 validNodes.add((ILsaNode) neigh);
diff --git a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/SendScafiMessage.scala b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/SendScafiMessage.scala
index 77165e5827..9b160cc9b5 100644
--- a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/SendScafiMessage.scala
+++ b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/SendScafiMessage.scala
@@ -28,6 +28,13 @@ class SendScafiMessage[T, P <: Position[P]](
   assert(reaction != null, "Reaction cannot be null")
   assert(program != null, "Program cannot be null")
 
+  private var neighbors: Iterator[Node[T]] = Iterator.empty
+  environment.getNeighborhood(device.getNode).onChange(this, neighborhood => {
+      neighbors = neighborhood.getNeighbors.iterator().asScala
+      kotlin.Unit.INSTANCE
+    }
+  )
+
   /**
    * This method allows to clone this action on a new node. It may result useful to support runtime creation of nodes
    * with the same reaction programming, e.g. for morphogenesis.
@@ -64,7 +71,7 @@ class SendScafiMessage[T, P <: Position[P]](
   override def execute(): Unit = {
     val toSend = program.getExport(device.getNode.getId).get
     for {
-      neighborhood <- environment.getNeighborhood(device.getNode).getNeighbors.iterator().asScala
+      neighborhood <- neighbors
       action <- ScafiIncarnationUtils.allScafiProgramsFor[T, P](neighborhood).filter(program.getClass.isInstance(_))
       if action.programNameMolecule == program.programNameMolecule
     } action.sendExport(device.getNode.getId, toSend)
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodeDegree.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodeDegree.kt
index 6004eb8844..242c4027fa 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodeDegree.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodeDegree.kt
@@ -32,7 +32,7 @@ constructor(filter: ExportFilter, aggregators: List<String>, precision: Int = 2)
         time: Time,
         step: Long,
     ): Map<Node<T>, Double> = environment.nodes.associateWith { node ->
-        environment.getNeighborhood(node).size().toDouble()
+        environment.getNeighborhood(node).current.size().toDouble()
     }
 
     private companion object {
diff --git a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStream.kt b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStream.kt
index 00bc84aa02..fa4c879223 100644
--- a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStream.kt
+++ b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStream.kt
@@ -29,7 +29,7 @@ class TestGraphStream :
                 environment.nodeCount shouldBeExactly 400
                 "with neighbors closer than non-neighbors" {
                     environment.nodes.forEach { node ->
-                        val neighborhood = environment.getNeighborhood(node)
+                        val neighborhood = environment.getNeighborhood(node).current
                         val averageDistances =
                             environment.nodes
                                 .asSequence()
@@ -49,7 +49,7 @@ class TestGraphStream :
             "create links" - {
                 val neighborhoods =
                     environment.nodes
-                        .map { environment.getNeighborhood(it).neighbors }
+                        .map { environment.getNeighborhood(it).current.neighbors }
                 neighborhoods.forEach { it.shouldNotBeEmpty() }
                 "asymmetrically" {
                     println(neighborhoods)
diff --git a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStreamReproducibility.kt b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStreamReproducibility.kt
index ea487ab63b..f7df0acd20 100644
--- a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStreamReproducibility.kt
+++ b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStreamReproducibility.kt
@@ -59,7 +59,7 @@ class TestGraphStreamReproducibility :
                         }
                         environment.nodes.map { node ->
                             environment.getPosition(node).coordinates.toList() to
-                                environment.getNeighborhood(node).neighbors.map { it.id }
+                                environment.getNeighborhood(node).current.neighbors.map { it.id }
                         }
                     }
                     val graphs1 = generateGraphs()
diff --git a/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/linkingrules/TestInSightConnection.kt b/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/linkingrules/TestInSightConnection.kt
index 66ad31b7df..2315bcffc6 100644
--- a/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/linkingrules/TestInSightConnection.kt
+++ b/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/linkingrules/TestInSightConnection.kt
@@ -38,7 +38,7 @@ class TestInSightConnection :
                 environment.getDistanceBetweenNodes(node0, node1) shouldBeLessThan maxRange
                 val route = environment.computeRoute(node0, node1)
                 route.length() shouldBeGreaterThan maxRange
-                environment.getNeighborhood(node0).contains(node1).shouldBeFalse()
+                environment.getNeighborhood(node0).current.contains(node1).shouldBeFalse()
             }
         },
     )
diff --git a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/monitor/impl/Generic2DDisplay.java b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/monitor/impl/Generic2DDisplay.java
index fce553dc6f..f29cdcaef5 100644
--- a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/monitor/impl/Generic2DDisplay.java
+++ b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/monitor/impl/Generic2DDisplay.java
@@ -717,7 +717,7 @@ private void update(final Environment<T, P> environment, final Time time) {
             neighbors.clear();
             environment.getNodes().parallelStream().forEach(node -> {
                 positions.put(node, environment.getPosition(node));
-                neighbors.put(node, environment.getNeighborhood(node));
+                neighbors.put(node, environment.getNeighborhood(node).getCurrent());
             });
             releaseData();
             repaint();

From c4255529783750d9a67f73ab10006e1422b518b9 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Wed, 21 Jan 2026 18:54:03 +0100
Subject: [PATCH 06/29] feat!: make node counting observable

---
 .../it/unibo/alchemist/model/Environment.kt     |  7 +------
 .../TestTerminationPredicateSerialization.kt    |  4 ++--
 .../environments/TestEnvironmentWithDynamics.kt |  2 +-
 .../obstacles/TestContinuous2DObstacle.java     | 10 +++++-----
 .../alchemist/model/linkingrules/ClosestN.java  | 12 ++++++++----
 .../model/environments/AbstractEnvironment.kt   |  6 ++----
 .../model/linkingrules/FullyConnected.kt        |  8 ++++----
 .../model/terminators/StableForSteps.kt         |  2 +-
 .../it/unibo/alchemist/util/Environments.kt     | 17 +++++++++--------
 .../alchemist/util/TestEnvironmentsDiameter.kt  |  7 +------
 .../conditions/BiomolPresentInNeighbor.kt       |  4 ++++
 .../boundary/extractors/NetworkCentroid.kt      |  4 ++--
 .../boundary/extractors/NetworkDensity.kt       |  2 +-
 .../boundary/extractors/NodesPositions.kt       |  6 +++---
 .../boundary/extractors/NumberOfNodes.kt        |  2 +-
 .../alchemist/model/util/GraphStreamSupport.kt  |  2 +-
 .../unibo/alchemist/model/TestLoadGPSTrace.java |  2 +-
 .../it/unibo/alchemist/test/TestGraphStream.kt  |  2 +-
 .../maps/linkingrules/TestInSightConnection.kt  |  2 +-
 .../swingui/effect/impl/DrawDirectedNode.kt     |  2 +-
 20 files changed, 50 insertions(+), 53 deletions(-)

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
index 5aff97c1ee..5ec0a72669 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
@@ -116,15 +116,10 @@ interface Environment<T, P : Position<out P>> :
      */
     val observableNodes: ObservableSet<Node<T>>
 
-    /**
-     * Returns the number of [Node]s currently in the [Environment].
-     */
-    val nodeCount: Int
-
     /**
      * Returns an [Observable] view of the number of [Node]s currently in the [Environment].
      */
-    val observeNodeCount: Observable<Int>
+    val nodeCount: Observable<Int>
 
     /**
      * Given a [node] this method returns a list of all the surrounding
diff --git a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/TestTerminationPredicateSerialization.kt b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/TestTerminationPredicateSerialization.kt
index 34149369bf..401facf435 100644
--- a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/TestTerminationPredicateSerialization.kt
+++ b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/TestTerminationPredicateSerialization.kt
@@ -14,7 +14,7 @@ class TestTerminationPredicateSerialization {
     fun `termination predicates can be serialized and deserialized`() {
         // Create a predicate that checks if the environment has more than 100 nodes
         val originalPredicate: TerminationPredicate<Int, Position<*>> =
-            TerminationPredicate { env -> env.nodeCount > 100 }
+            TerminationPredicate { env -> env.nodeCount.current > 100 }
         // Serialize the predicate
         val serializedBytes = serialize(originalPredicate)
         // Deserialize the predicate
@@ -22,7 +22,7 @@ class TestTerminationPredicateSerialization {
             deserialize(serializedBytes)
         // Check that the deserialized predicate works as expected
         val mockEnvironment = mockk<Environment<Int, Position<*>>>()
-        every { mockEnvironment.nodeCount } returns 101
+        every { mockEnvironment.nodeCount.current } returns 101
         assertEquals(originalPredicate(mockEnvironment), deserializedPredicate(mockEnvironment)) {
             "Deserialized predicate should behave the same as the original"
         }
diff --git a/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/environments/TestEnvironmentWithDynamics.kt b/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/environments/TestEnvironmentWithDynamics.kt
index ee35c57633..7ad69dbbb7 100644
--- a/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/environments/TestEnvironmentWithDynamics.kt
+++ b/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/environments/TestEnvironmentWithDynamics.kt
@@ -33,7 +33,7 @@ class TestEnvironmentWithDynamics<T, P> :
                             environment.shapeFactory.rectangle(120.0, 120.0).transformed {
                                 origin(environment.origin)
                             },
-                        ).size shouldBe environment.nodeCount
+                        ).size shouldBe environment.nodeCount.current
                 },
             )
         }
diff --git a/alchemist-euclidean-geometry/src/test/java/it/unibo/alchemist/model/obstacles/TestContinuous2DObstacle.java b/alchemist-euclidean-geometry/src/test/java/it/unibo/alchemist/model/obstacles/TestContinuous2DObstacle.java
index 021392acc6..74a77e5d0e 100644
--- a/alchemist-euclidean-geometry/src/test/java/it/unibo/alchemist/model/obstacles/TestContinuous2DObstacle.java
+++ b/alchemist-euclidean-geometry/src/test/java/it/unibo/alchemist/model/obstacles/TestContinuous2DObstacle.java
@@ -68,16 +68,16 @@ void test() {
         );
 
         environment.addNode(createIntNode(incarnation, environment), new Euclidean2DPosition(0, 0));
-        assertEquals(1, environment.getNodeCount());
+        assertEquals(1, environment.getNodeCount().getCurrent());
         environment.addNode(createIntNode(incarnation, environment), new Euclidean2DPosition(1, 1));
-        assertEquals(1, environment.getNodeCount());
+        assertEquals(1, environment.getNodeCount().getCurrent());
         // CHECKSTYLE: MagicNumber OFF
         environment.addNode(createIntNode(incarnation, environment), new Euclidean2DPosition(1.5, 0.5));
-        assertEquals(1, environment.getNodeCount());
+        assertEquals(1, environment.getNodeCount().getCurrent());
         environment.addNode(createIntNode(incarnation, environment), new Euclidean2DPosition(1, 5));
-        assertEquals(1, environment.getNodeCount());
+        assertEquals(1, environment.getNodeCount().getCurrent());
         environment.addNode(createIntNode(incarnation, environment), new Euclidean2DPosition(1, 2.999));
-        assertEquals(2, environment.getNodeCount());
+        assertEquals(2, environment.getNodeCount().getCurrent());
         assertEquals(2, environment.getObstaclesInRange(0d, 0d, 100d).size());
         assertEquals(1, environment.getObstaclesInRange(0d, 0d, 1d).size());
         assertEquals(R1021, environment.getObstaclesInRange(0d, 0d, 1d).get(0));
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ClosestN.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ClosestN.java
index 529f484e02..1ee402921d 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ClosestN.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ClosestN.java
@@ -100,7 +100,7 @@ private Cache<Node<T>, Double> ranges() {
 
     @Override
     public final Neighborhood<T> computeNeighborhood(final Node<T> center, final Environment<T, P> environment) {
-        if (environment.getNodeCount() < expectedNodes || !nodeIsEnabled(center)) {
+        if (environment.getNodeCount().getCurrent() < expectedNodes || !nodeIsEnabled(center)) {
             return Neighborhoods.make(environment, center);
         }
         return Neighborhoods.make(environment, center,
@@ -130,13 +130,17 @@ private Stream<Node<T>> closestN(final Node<T> center, final Environment<T, ?> e
         Set<Node<T>> inRange;
         final double maxRange = Doubles.max(environment.getSizeInDistanceUnits()) * 2;
         do {
-            inRange = (environment.getNodeCount() > nodeCount && currentRange < maxRange
+            inRange = (environment.getNodeCount().getCurrent() > nodeCount && currentRange < maxRange
                     ? nodesInRange(environment, center, currentRange).stream()
                     : environment.getNodes().stream())
                         .filter(n -> !n.equals(center) && nodeIsEnabled(n))
                         .collect(Collectors.toCollection(LinkedHashSet::new));
             currentRange *= 2;
-        } while (inRange.size() < nodeCount && inRange.size() < environment.getNodeCount() - 1 && currentRange < maxRange * 2);
+        } while (
+            inRange.size() < nodeCount
+                && inRange.size() < environment.getNodeCount().getCurrent() - 1
+                && currentRange < maxRange * 2
+        );
         if (inRange.isEmpty()) {
             return Stream.empty();
         }
@@ -200,7 +204,7 @@ protected final double getRange(final Environment<T, ?> environment, final Node<
              * would, on average, contain the number of required devices
              */
             return ranges().get(center, () -> {
-                final int nodes = environment.getNodeCount();
+                final int nodes = environment.getNodeCount().getCurrent();
                 if (nodes < nodeCount || nodes < 10) {
                     return Double.MAX_VALUE;
                 }
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
index 9e65e10336..083e186b60 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
@@ -83,10 +83,8 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
     @Transient
     override val observableNodes: ObservableMutableSet<Node<T>> = _nodes.toList().toObservableSet()
 
-    final override val nodeCount: Int get() = nodes.size
-
     @Transient
-    override val observeNodeCount: Observable<Int> = observableNodes.observableSize
+    final override val nodeCount: Observable<Int> = observableNodes.observableSize
 
     private val regionObservers = ArrayList<RegionObserver>()
 
@@ -551,7 +549,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
                 }
             }
         } else {
-            val processed = TIntHashSet(nodeCount).apply { add(node.id) }
+            val processed = TIntHashSet(nodes.size).apply { add(node.id) }
             val operations = recursiveOperation(node).toMutableList()
             while (operations.isNotEmpty()) {
                 val next = operations.removeLast()
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/linkingrules/FullyConnected.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/linkingrules/FullyConnected.kt
index ec27ce78cd..b94f5ad792 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/linkingrules/FullyConnected.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/linkingrules/FullyConnected.kt
@@ -30,7 +30,7 @@ class FullyConnected<T, P : Position<P>> : LinkingRule<T, P> {
 
         override fun getCenter() = center
 
-        override fun isEmpty() = environment.nodeCount <= 1
+        override fun isEmpty() = environment.nodeCount.current <= 1
 
         override fun getNeighbors() = object : ListSet<Node<T>> {
             override fun get(index: Int) = BugReporting.reportBug("Not implemented")
@@ -67,13 +67,13 @@ class FullyConnected<T, P : Position<P>> : LinkingRule<T, P> {
 
             override fun retainAll(elements: Collection<Node<T>>) = BugReporting.reportBug("Not implemented")
 
-            override val size = environment.nodeCount - 1
+            override val size = environment.nodeCount.current - 1
 
             override fun contains(element: Node<T>?) = element != center && environment.contains(element)
 
             override fun containsAll(elements: Collection<Node<T>>) = elements.all { contains(it) }
 
-            override fun isEmpty() = environment.nodeCount == 1
+            override fun isEmpty() = environment.nodeCount.current == 1
         }
 
         override fun remove(node: Node<T>?) = this
@@ -82,6 +82,6 @@ class FullyConnected<T, P : Position<P>> : LinkingRule<T, P> {
 
         override fun iterator() = neighbors.iterator()
 
-        override fun size() = environment.nodeCount - 1
+        override fun size() = environment.nodeCount.current - 1
     }
 }
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/terminators/StableForSteps.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/terminators/StableForSteps.kt
index fe00fe05a3..b84b1a828c 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/terminators/StableForSteps.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/terminators/StableForSteps.kt
@@ -56,7 +56,7 @@ data class StableForSteps<T : Any, P : Position<P>>(private val checkInterval: L
     override fun invoke(environment: Environment<T, P>): Boolean {
         if (environment.simulation.step % checkInterval == 0L) {
             val newPositions = environment.associateBy({ it }, { environment.getPosition(it) })
-            val newContents = makeTable<T>(environment.nodeCount)
+            val newContents = makeTable<T>(environment.nodeCount.current)
             environment.forEach { node ->
                 node.contents.forEach { (molecule, concentration) ->
                     newContents.put(node, molecule, concentration)
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/util/Environments.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/util/Environments.kt
index e1cf356288..0b5a380b6d 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/util/Environments.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/util/Environments.kt
@@ -64,7 +64,7 @@ object Environments {
     fun <T> Environment<T, *>.allSubNetworksByNode(
         computeDistance: (Node<T>, Node<T>) -> Double = environmentMetricDistance(),
     ): Map<Node<T>, Network<T>> {
-        val subnetworks = arrayOfNulls<MutableNetwork<T>>(nodeCount)
+        val subnetworks = arrayOfNulls<MutableNetwork<T>>(nodeCount.current)
         val result = mutableMapOf<Node<T>, Network<T>>()
         val paths = allShortestPaths(computeDistance)
         // Update all the subnetworks with the last evaluated; that is the most complete
@@ -74,7 +74,7 @@ object Environments {
                     val newSubnetwork = MutableNetwork(0.0, mutableListOf(centerNode))
                     result[centerNode] = newSubnetwork
                     val centerRow = paths.row(centerIndex)
-                    for (potentialNeighborIndex in centerIndex + 1 until nodeCount) {
+                    for (potentialNeighborIndex in centerIndex + 1 until nodeCount.current) {
                         val distanceToNeighbor = centerRow[potentialNeighborIndex]
                         if (distanceToNeighbor.isFinite()) {
                             newSubnetwork.diameter = max(newSubnetwork.diameter, distanceToNeighbor)
@@ -125,18 +125,19 @@ object Environments {
             },
     ): SymmetricMatrix<Double> {
         val nodes = nodes.toList()
+        val currentNodeCount = nodeCount.current
         /*
          * The distance matrix is a triangular matrix stored in a flat array.
          */
-        val distances = MutableDoubleSymmetricMatrix(nodeCount)
-        for (i in 0 until nodeCount) {
-            for (j in i until nodeCount) {
+        val distances = MutableDoubleSymmetricMatrix(currentNodeCount)
+        for (i in 0 until currentNodeCount) {
+            for (j in i until currentNodeCount) {
                 distances[i, j] = computeDistance(nodes[i], nodes[j])
             }
         }
-        for (intermediate in 0 until nodeCount) {
-            for (i in 0 until nodeCount) {
-                for (j in i + 1 until nodeCount) {
+        for (intermediate in 0 until currentNodeCount) {
+            for (i in 0 until currentNodeCount) {
+                for (j in i + 1 until currentNodeCount) {
                     val throughIntermediate = distances[i, intermediate] + distances[intermediate, j]
                     if (distances[i, j] > throughIntermediate) {
                         distances[i, j] = throughIntermediate
diff --git a/alchemist-implementationbase/src/test/kotlin/it/unibo/alchemist/util/TestEnvironmentsDiameter.kt b/alchemist-implementationbase/src/test/kotlin/it/unibo/alchemist/util/TestEnvironmentsDiameter.kt
index 7dbc6b0a66..442d5e53c5 100644
--- a/alchemist-implementationbase/src/test/kotlin/it/unibo/alchemist/util/TestEnvironmentsDiameter.kt
+++ b/alchemist-implementationbase/src/test/kotlin/it/unibo/alchemist/util/TestEnvironmentsDiameter.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2025, Danilo Pianini and contributors
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
  * listed, for each module, in the respective subproject's build.gradle.kts file.
  *
  * This file is part of Alchemist, and is distributed under the terms of the
@@ -11,14 +11,9 @@ package it.unibo.alchemist.util
 
 import it.unibo.alchemist.model.Environment
 import it.unibo.alchemist.util.Environments.allSubNetworks
-import it.unibo.alchemist.util.Environments.allSubNetworksByNode
-import it.unibo.alchemist.util.Environments.isNetworkSegmented
-import java.math.BigDecimal
-import java.math.RoundingMode
 import kotlin.math.hypot
 import kotlin.math.sqrt
 import kotlin.test.assertEquals
-import kotlin.test.assertFalse
 import org.junit.jupiter.api.Test
 
 object TestEnvironmentsDiameter {
diff --git a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.kt b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.kt
index 578c697edf..96ac360d9b 100644
--- a/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.kt
+++ b/alchemist-incarnation-biochemistry/src/main/kotlin/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInNeighbor.kt
@@ -85,6 +85,10 @@ class BiomolPresentInNeighbor(
      * This object stores the `serialVersionUID` constant required for serialization purposes.
      */
     companion object {
+
+        /**
+         * Unique ID for deserialization purposes.
+         */
         @Serial const val serialVersionUID: Long = 499903479123400111L
     }
 }
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkCentroid.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkCentroid.kt
index 8be413230f..ca81e0fe9f 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkCentroid.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkCentroid.kt
@@ -25,7 +25,7 @@ class NetworkCentroid : Extractor<Double> {
         reaction: Actionable<T>?,
         time: Time,
         step: Long,
-    ): Map<String, Double> = when (environment.nodeCount) {
+    ): Map<String, Double> = when (environment.nodeCount.current) {
         0 -> columnNames.associateWith { NaN }
         else ->
             environment.networkHub().toList().mapIndexed { index, value ->
@@ -40,6 +40,6 @@ class NetworkCentroid : Extractor<Double> {
                 sums[index] += value
             }
         }
-        return sums.map { it / nodeCount }
+        return sums.map { it / nodeCount.current }
     }
 }
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkDensity.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkDensity.kt
index 5ece6247dc..19ad8a5ab3 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkDensity.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkDensity.kt
@@ -46,7 +46,7 @@ class NetworkDensity : Extractor<Double> {
         val area = (boundingBox.maxX - boundingBox.minX) * (boundingBox.maxY - boundingBox.minY)
         return when {
             area <= 0 || area.isInfinite() -> Double.NaN
-            else -> nodeCount / area
+            else -> nodeCount.current / area
         }
     }
 }
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodesPositions.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodesPositions.kt
index f63ec8d5a4..4811b1089d 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodesPositions.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodesPositions.kt
@@ -22,13 +22,13 @@ import it.unibo.alchemist.model.Time
  */
 class NodesPositions<T, P : Position<P>>(private val environment: Environment<T, P>) : AbstractDoubleExtractor() {
     override val columnNames: List<String> by lazy {
-        (0 until environment.nodeCount).flatMap { nodeId ->
+        (0 until environment.nodeCount.current).flatMap { nodeId ->
             (0 until environment.dimensions).map { dimensionIndex ->
                 columnNameFormat(nodeId, Dimension(dimensionIndex))
             }
         }
     }
-    private val expectedNodesCount: Int by lazy { environment.nodeCount }
+    private val expectedNodesCount: Int by lazy { environment.nodeCount.current }
     private val maxNodeId: Int by lazy {
         environment.nodes.maxOfOrNull { it.id } ?: error("No nodes in the environment")
     }
@@ -51,7 +51,7 @@ class NodesPositions<T, P : Position<P>>(private val environment: Environment<T,
     }
 
     private fun <T> checkExtractCondition(environment: Environment<T, *>) {
-        require(expectedNodesCount == environment.nodeCount) {
+        require(expectedNodesCount == environment.nodeCount.current) {
             "The number of nodes in the environment is ${environment.nodeCount}, but $expectedNodesCount was expected"
         }
         val currentMaxNodeId = environment.nodes.maxOfOrNull { it.id } ?: error("No nodes in the environment")
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NumberOfNodes.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NumberOfNodes.kt
index 125c608d9d..3344507104 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NumberOfNodes.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NumberOfNodes.kt
@@ -25,7 +25,7 @@ class NumberOfNodes : Extractor<Int> {
         reaction: Actionable<T>?,
         time: Time,
         step: Long,
-    ): Map<String, Int> = mapOf(NAME to environment.nodeCount)
+    ): Map<String, Int> = mapOf(NAME to environment.nodeCount.current)
 
     private companion object {
         private const val NAME: String = "nodes"
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/model/util/GraphStreamSupport.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/model/util/GraphStreamSupport.kt
index 9a563e3379..655af9e966 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/model/util/GraphStreamSupport.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/model/util/GraphStreamSupport.kt
@@ -163,7 +163,7 @@ class GraphStreamSupport<T, P : Position<out P>>(val linkingRule: LinkingRule<T,
             val shift = ebeAdd(barycenter, offsets)
 
             fun DoubleArray.zoomAndPan(): DoubleArray = ebeAdd(shift, ebeMultiply(zooms, ebeSubtract(this, barycenter)))
-            return GraphStreamSupport(OffsetGraphStreamLinkingRule<T, P>(environment.nodeCount, graph)) {
+            return GraphStreamSupport(OffsetGraphStreamLinkingRule<T, P>(environment.nodeCount.current, graph)) {
                 originalCoordinates.stream().map {
                     val shifted = it.zoomAndPan()
                     if (is3D) {
diff --git a/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestLoadGPSTrace.java b/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestLoadGPSTrace.java
index 0285af0269..ce71a4ed7c 100755
--- a/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestLoadGPSTrace.java
+++ b/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestLoadGPSTrace.java
@@ -74,7 +74,7 @@ <T> void testLoadGPSTrace() {
         assertNotNull(res, "Missing test resource testgps.yml");
         final Simulation<T, GeoPosition> simulation = LoadAlchemist.from(res).getDefault();
         final Environment<T, GeoPosition> environment = simulation.getEnvironment();
-        assertTrue(environment.getNodeCount() > 0);
+        assertTrue(environment.getNodeCount().getCurrent() > 0);
         environment.getNodes().forEach(node -> {
             final var reactions = node.getReactions();
             assertFalse(reactions.isEmpty());
diff --git a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStream.kt b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStream.kt
index fa4c879223..88f92ef74b 100644
--- a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStream.kt
+++ b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStream.kt
@@ -26,7 +26,7 @@ class TestGraphStream :
                     .getDefault<Nothing, Nothing>()
                     .environment
             "displace all nodes" - {
-                environment.nodeCount shouldBeExactly 400
+                environment.nodeCount.current shouldBeExactly 400
                 "with neighbors closer than non-neighbors" {
                     environment.nodes.forEach { node ->
                         val neighborhood = environment.getNeighborhood(node).current
diff --git a/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/linkingrules/TestInSightConnection.kt b/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/linkingrules/TestInSightConnection.kt
index 2315bcffc6..3e67b18851 100644
--- a/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/linkingrules/TestInSightConnection.kt
+++ b/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/linkingrules/TestInSightConnection.kt
@@ -29,7 +29,7 @@ class TestInSightConnection :
                         .from(ResourceLoader.getResource("simulations/connect-sight.yml"))
                         .getDefault<Nothing, GeoPosition>()
                         .environment as OSMEnvironment
-                environment.nodeCount shouldBe 102
+                environment.nodeCount.current shouldBe 102
                 val node0 = environment.getNodeByID(0)
                 val node1 = environment.getNodeByID(1)
                 val rule = environment.linkingRule
diff --git a/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/effect/impl/DrawDirectedNode.kt b/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/effect/impl/DrawDirectedNode.kt
index 170d92c389..8f88398196 100644
--- a/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/effect/impl/DrawDirectedNode.kt
+++ b/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/effect/impl/DrawDirectedNode.kt
@@ -139,7 +139,7 @@ class DrawDirectedNode : it.unibo.alchemist.boundary.swingui.effect.api.Effect {
         ?.toDouble()
         ?.let {
             Color.getHSBColor(
-                (it / (maxValue.toDoubleOrNull() ?: environment.nodeCount.toDouble())).toFloat(),
+                (it / (maxValue.toDoubleOrNull() ?: environment.nodeCount.current.toDouble())).toFloat(),
                 1f,
                 1f,
             )

From 5995c804518c80410afec9219008d06c3259f774 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 22 Jan 2026 09:51:56 +0100
Subject: [PATCH 07/29] fix(biochemistry): use current node count in assertions

---
 .../model/biochemistry/actions/TestChemotaxis.java          | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/actions/TestChemotaxis.java b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/actions/TestChemotaxis.java
index e47cec940d..a0771cd57d 100644
--- a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/actions/TestChemotaxis.java
+++ b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/actions/TestChemotaxis.java
@@ -232,7 +232,7 @@ void testChemotacticMove1() {
         environment.addNode(envNode3, p3);
         environment.addNode(envNode4, p4);
         environment.addNode(cellNode1, p5);
-        assertEquals(EXPECTED_NODES, environment.getNodeCount());
+        assertEquals(EXPECTED_NODES, environment.getNodeCount().getCurrent());
         envNode4.setConcentration(biomolA, CONCENTRATION2);
         envNode2.setConcentration(biomolA, CONCENTRATION1);
         envNode3.setConcentration(biomolA, CONCENTRATION1);
@@ -262,7 +262,7 @@ void testChemotacticMove2() {
         environment.addNode(envNode3, p3);
         environment.addNode(envNode4, p4);
         environment.addNode(cellNode1, p5);
-        assertEquals(EXPECTED_NODES, environment.getNodeCount());
+        assertEquals(EXPECTED_NODES, environment.getNodeCount().getCurrent());
         envNode4.setConcentration(biomolA, CONCENTRATION2);
         envNode2.setConcentration(biomolA, CONCENTRATION1);
         envNode3.setConcentration(biomolA, CONCENTRATION1);
@@ -297,7 +297,7 @@ void testChemotacticMove3() {
         environment.addNode(envNode3, p3);
         environment.addNode(envNode4, p4);
         environment.addNode(cellNode1, p5);
-        assertEquals(EXPECTED_NODES, environment.getNodeCount());
+        assertEquals(EXPECTED_NODES, environment.getNodeCount().getCurrent());
         envNode4.setConcentration(biomolA, CONCENTRATION2);
         envNode2.setConcentration(biomolA, CONCENTRATION2);
         envNode3.setConcentration(biomolA, CONCENTRATION2);

From 878efbc45862e34d41b4594c3d806531c9d29db7 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 22 Jan 2026 10:06:52 +0100
Subject: [PATCH 08/29] chore(api): add `updateOrNull` with observable map
 values

---
 .../alchemist/model/observation/ObservableMap.kt     | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
index 08a1af8fb9..736581ce9e 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
@@ -13,6 +13,7 @@ import arrow.core.Option
 import arrow.core.none
 import arrow.core.some
 import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
+import it.unibo.alchemist.model.observation.Observable.ObservableExtensions.currentOrNull
 import java.util.Collections
 
 /**
@@ -248,5 +249,16 @@ open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> =
                 valueUpdate(it.getOrNull()).apply { put(key, this) }.some()
             }
         }
+
+        /**
+         * Updates the value associated with the given key in the map by applying the provided transformation function.
+         * If the key does not exist or its current value is `null`, no operation is performed, and `null` is returned.
+         *
+         * @param key The key whose associated value is to be updated.
+         * @param valueUpdate A function that defines how the current value should be updated.
+         * @return The updated value if the key exists and its value is not `null`; otherwise, `null`.
+         */
+        fun <K, V> ObservableMutableMap<K, V>.updateOrNull(key: K, valueUpdate: V.() -> Unit): V? =
+            this[key].currentOrNull()?.let { it.apply(valueUpdate).also { new -> this[key] = new } }
     }
 }

From c7d80091c4545ecd6f000c1efd4ac0421babd9ed Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 22 Jan 2026 10:26:13 +0100
Subject: [PATCH 09/29] feat!: fully transition to observable positions

---
 .../it/unibo/alchemist/model/Environment.kt   |   8 +-
 .../alchemist/model/EuclideanEnvironment.kt   |   2 +-
 .../cognitive/SteeringActionWithTarget.kt     |   2 +-
 .../actions/AbstractGroupSteeringAction.kt    |   2 +-
 .../actions/AbstractNavigationAction.kt       |   4 +-
 .../actions/CognitiveAgentAvoidLayer.kt       |   2 +-
 .../environments/EnvironmentWithDynamics.kt   |   4 +-
 .../model/cognitive/navigation/Explore.kt     |   2 +-
 .../model/cognitive/properties/Cognitive.kt   |   2 +-
 .../properties/PhysicalPedestrian2D.kt        |   6 +-
 .../model/cognitive/steering/Weighted.kt      |   2 +-
 .../model/cognitive/TestFeelsTransmission.kt  |   2 +-
 .../model/cognitive/TestOrientingBehavior.kt  |  10 +-
 .../model/cognitive/TestSteeringBehaviors.kt  |  22 ++--
 .../properties/TestPhysicalPedestrians.kt     |   2 +-
 .../model/linkingrules/ConnectionBeam.java    |   4 +-
 .../model/actions/FollowAtDistance.kt         |   2 +-
 .../model/movestrategies/RandomTarget.kt      |   2 +-
 .../model/surrogates/EnvironmentSurrogate.kt  |   2 +-
 .../schema/model/EnvironmentSurrogateTest.kt  |   2 +-
 .../actions/AbstractConfigurableMoveNode.java |   2 +-
 .../model/actions/AbstractMoveNode.java       |   4 +-
 .../model/actions/MoveForwardAndTeleport.java |   2 +-
 .../ObstaclesBreakConnection.java             |   8 +-
 .../model/environments/AbstractEnvironment.kt |  13 +-
 .../movestrategies/target/FollowTarget.kt     |   2 +-
 .../model/terminators/StableForSteps.kt       |   2 +-
 .../actions/CellTensionPolarization.java      |   4 +-
 .../actions/ChemotacticPolarization.java      |   8 +-
 .../conditions/BiomolPresentInEnv.java        |   2 +-
 .../BioRect2DEnvironmentNoOverlap.java        |  10 +-
 .../biochemistry/actions/TestChemotaxis.java  |  10 +-
 .../TestBioRect2DEnvironmentNoOverlap.java    | 112 +++++++++---------
 .../biochemistry/layers/TestBiomolLayer.java  |   2 +-
 .../nodes/TestEnvironmentNodes.java           |   8 +-
 .../properties/TestDeformableCell.java        |  12 +-
 .../protelis/AlchemistExecutionContext.kt     |   5 +-
 .../protelis/properties/ProtelisDevice.kt     |   2 +-
 .../actions/AbstractSAPEREMoveNodeAgent.java  |   6 +-
 .../actions/AbstractSAPERENeighborAgent.java  |   9 +-
 .../actions/SAPEREWalkerRiseGradient.java     |   6 +-
 .../sapere/reactions/SAPEREGradient.java      |   4 +-
 .../sapere/reactions/SAPEREReaction.java      |   4 +-
 .../scafi/ScafiIncarnationForAlchemist.scala  |   2 +-
 .../model/scafi/actions/RunScafiProgram.scala |   2 +-
 .../boundary/extractors/NetworkCentroid.kt    |   2 +-
 .../boundary/extractors/NetworkDensity.kt     |   2 +-
 .../boundary/extractors/NodesPositions.kt     |   2 +-
 .../deployments/CloseToAlreadyDeployed.kt     |   2 +-
 .../alchemist/model/TestLoadGPSTrace.java     |   4 +-
 .../unibo/alchemist/model/TestYAMLLoader.java |   2 +-
 .../test/TestGraphStreamReproducibility.kt    |   2 +-
 .../alchemist/test/TestSpecificPositions.kt   |   2 +-
 .../maps/environments/OSMEnvironment.java     |   4 +-
 .../StraightLineTraceDependantSpeed.java      |   2 +-
 .../actions/RandomTargetInPolygonOnMap.kt     |   2 +-
 .../model/maps/actions/TestTargetMapWalker.kt |  32 ++---
 .../physics/environments/MuseumHall.java      |   4 +-
 .../model/physics/InfluenceSphere2D.kt        |   2 +-
 .../model/physics/actions/HeadTowardTarget.kt |   4 +-
 .../AbstractLimitedContinuous2D.kt            |   2 +-
 .../ContinuousPhysics2DEnvironment.kt         |   4 +-
 .../TestEuclideanPhysics2DEnvironment.kt      |  10 +-
 ...ameraInjectVisibleNodeClosestToDistance.kt |   2 +-
 .../alchemist/model/actions/CameraSee.kt      |   2 +-
 .../boundary/swingui/effect/api/Effect.java   |   2 +-
 .../swingui/effect/impl/AbstractDrawOnce.java |   2 +-
 .../effect/impl/DrawPedestrianPath.java       |   2 +-
 .../swingui/effect/impl/DrawSmartcam.java     |   2 +-
 .../monitor/impl/Generic2DDisplay.java        |   4 +-
 .../boundary/wormhole/impl/MapWormhole.java   |   2 +-
 .../swingui/effect/impl/DrawDirectedNode.kt   |   4 +-
 .../swingui/monitor/impl/NodeTracker.kt       |   2 +-
 .../surrogates/utility/ToNodeSurrogate.kt     |   2 +-
 .../server/utility/ToNodeSurrogateTest.kt     |   2 +-
 75 files changed, 229 insertions(+), 208 deletions(-)

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
index 5ec0a72669..1b81c463cd 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Environment.kt
@@ -157,14 +157,14 @@ interface Environment<T, P : Position<out P>> :
     val offset: DoubleArray
 
     /**
-     * Calculates the position of a [node].
+     * Observe the position of a [node].
      */
-    fun getPosition(node: Node<T>): P
+    fun getPosition(node: Node<T>): Observable<P>
 
     /**
-     * Observe the position of a [node].
+     * Retrieves [node]'s current position.
      */
-    fun observePosition(node: Node<T>): Observable<P>
+    fun getCurrentPosition(node: Node<T>): P = getPosition(node).current
 
     /**
      * Return the current [Simulation], if present, or throws an [IllegalStateException] otherwise.
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/EuclideanEnvironment.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/EuclideanEnvironment.kt
index c240de013b..db0a979a32 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/EuclideanEnvironment.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/EuclideanEnvironment.kt
@@ -25,7 +25,7 @@ interface EuclideanEnvironment<T, P> : Environment<T, P> where P : Position<P>,
      * method may suffice.
      */
     fun moveNode(node: Node<T>, direction: P) {
-        val oldcoord = getPosition(node)
+        val oldcoord = getCurrentPosition(node)
         moveNodeToPosition(node, oldcoord.plus(direction))
     }
 
diff --git a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/SteeringActionWithTarget.kt b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/SteeringActionWithTarget.kt
index e4fe0c6aeb..425ce1165e 100644
--- a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/SteeringActionWithTarget.kt
+++ b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/SteeringActionWithTarget.kt
@@ -36,5 +36,5 @@ interface SteeringActionWithTarget<T, P> : SteeringAction<T, P> where P : Positi
      * @return the distance from the action's target to the node's position.
      */
     fun targetDistanceTo(node: Node<T>, environment: Environment<T, P>): Double =
-        target().distanceTo(environment.getPosition(node))
+        target().distanceTo(environment.getCurrentPosition(node))
 }
diff --git a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/AbstractGroupSteeringAction.kt b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/AbstractGroupSteeringAction.kt
index cac7032c34..f13a1e461a 100644
--- a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/AbstractGroupSteeringAction.kt
+++ b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/AbstractGroupSteeringAction.kt
@@ -33,6 +33,6 @@ abstract class AbstractGroupSteeringAction<T, P, A>(
      * Computes the centroid of the [group] in absolute coordinates.
      */
     protected fun centroid(): P = with(group()) {
-        map { environment.getPosition(it) }.reduce { acc, pos -> acc + pos } / size.toDouble()
+        map { environment.getCurrentPosition(it) }.reduce { acc, pos -> acc + pos } / size.toDouble()
     }
 }
diff --git a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/AbstractNavigationAction.kt b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/AbstractNavigationAction.kt
index ebeaaccdbf..f7677c92d2 100644
--- a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/AbstractNavigationAction.kt
+++ b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/AbstractNavigationAction.kt
@@ -127,7 +127,7 @@ abstract class AbstractNavigationAction<T, P, A, L, R, N, E>(
      * Otherwise the first room containing [pedestrianPosition] is used.
      */
     protected open fun updateCachedVariables() {
-        pedestrianPosition = environment.getPosition(navigatingNode)
+        pedestrianPosition = environment.getCurrentPosition(navigatingNode)
         currentRoom =
             when {
                 (state == MOVING_TO_CROSSING_POINT_1 || state == MOVING_TO_FINAL) &&
@@ -223,7 +223,7 @@ abstract class AbstractNavigationAction<T, P, A, L, R, N, E>(
         /*
          * Always up to date current position.
          */
-            else -> environment.getPosition(navigatingNode)
+            else -> environment.getCurrentPosition(navigatingNode)
         }
 
     /**
diff --git a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/CognitiveAgentAvoidLayer.kt b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/CognitiveAgentAvoidLayer.kt
index b708f4a89c..ccf88df75f 100644
--- a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/CognitiveAgentAvoidLayer.kt
+++ b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/actions/CognitiveAgentAvoidLayer.kt
@@ -76,7 +76,7 @@ constructor(
      */
     @Suppress("UNCHECKED_CAST")
     private fun isDangerInSight(): Boolean = getLayerOrFail().center()?.let { center ->
-        val currentPosition = environment.getPosition(node)
+        val currentPosition = environment.getCurrentPosition(node)
         /*
          * environment is euclidean, so if it has obstacles it must be an
          * EnvironmentWithObstacles<*, *, Euclidean2DPosition>. Since generic types can't be checked at runtime, this
diff --git a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/environments/EnvironmentWithDynamics.kt b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/environments/EnvironmentWithDynamics.kt
index 76f3fa38d9..6fddaf0d31 100644
--- a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/environments/EnvironmentWithDynamics.kt
+++ b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/environments/EnvironmentWithDynamics.kt
@@ -149,7 +149,7 @@ constructor(
 
     override fun moveNode(node: Node<T>, direction: Euclidean2DPosition) {
         backingEnvironment.moveNode(node, direction)
-        moveNodeBodyToPosition(node, backingEnvironment.getPosition(node))
+        moveNodeBodyToPosition(node, backingEnvironment.getCurrentPosition(node))
     }
 
     private fun addPhysicalProperties(body: PhysicsBody, radius: Double) {
@@ -175,7 +175,7 @@ constructor(
         }
     }
 
-    override fun getPosition(node: Node<T>): Euclidean2DPosition = nodeToBody[node]?.position
+    override fun getCurrentPosition(node: Node<T>): Euclidean2DPosition = nodeToBody[node]?.position
         ?: throw IllegalArgumentException("Unable to find $node's position in the environment.")
 
     private val PhysicsBody.position get() =
diff --git a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/navigation/Explore.kt b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/navigation/Explore.kt
index c668301a2b..211bea49ca 100644
--- a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/navigation/Explore.kt
+++ b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/navigation/Explore.kt
@@ -125,7 +125,7 @@ open class Explore<T, L : Euclidean2DConvexShape, R>(
         environment
             .getNodesWithinRange(centroid, radius)
             .asSequence()
-            .map { environment.getPosition(it) }
+            .map { environment.getCurrentPosition(it) }
             .count { contains(it) }
             .let { it * node.area / area }
             .coerceAtMost(1.0)
diff --git a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/properties/Cognitive.kt b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/properties/Cognitive.kt
index e2e182e930..96b636b9d5 100644
--- a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/properties/Cognitive.kt
+++ b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/properties/Cognitive.kt
@@ -45,7 +45,7 @@ constructor(
         ) {
             when (danger) {
                 null -> 0.0
-                else -> environment.getLayer(danger)?.getValue(environment.getPosition(node)) as? Double ?: 0.0
+                else -> environment.getLayer(danger)?.getValue(environment.getCurrentPosition(node)) as? Double ?: 0.0
             }
         }
     }
diff --git a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/properties/PhysicalPedestrian2D.kt b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/properties/PhysicalPedestrian2D.kt
index 0c150c5e6f..935bc18e19 100644
--- a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/properties/PhysicalPedestrian2D.kt
+++ b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/properties/PhysicalPedestrian2D.kt
@@ -70,7 +70,7 @@ class PhysicalPedestrian2D<T>(
         environment
             .shapeFactory
             .circle(nodeShape.radius + comfortRay)
-            .transformed { origin(environment.getPosition(node)) }
+            .transformed { origin(environment.getCurrentPosition(node)) }
 
     override val rectangleOfInfluence: Euclidean2DShape get() =
         environment
@@ -84,7 +84,7 @@ class PhysicalPedestrian2D<T>(
     private val fallenAgentPerceptionArea
         get() = environment.shapeFactory.circle(FALLEN_AGENT_PERCEPTION_RADIUS).transformed { origin(node.position) }
 
-    private val Node<T>.position get() = environment.getPosition(this)
+    private val Node<T>.position get() = environment.getCurrentPosition(this)
 
     override fun checkAndPossiblyFall() {
         if (!isFallen && shouldFall(repulsionForces())) {
@@ -101,7 +101,7 @@ class PhysicalPedestrian2D<T>(
     }
 
     override fun repulse(other: Node<T>): Euclidean2DPosition {
-        val myShape = nodeShape.transformed { origin(environment.getPosition(node)) }
+        val myShape = nodeShape.transformed { origin(environment.getCurrentPosition(node)) }
         val otherShape = environment.getShape(other)
         return (myShape.centroid - otherShape.centroid).let {
             val desiredDistance = myShape.radius + comfortRay + otherShape.radius
diff --git a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/steering/Weighted.kt b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/steering/Weighted.kt
index e034754e86..4bc6b68ab2 100644
--- a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/steering/Weighted.kt
+++ b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/steering/Weighted.kt
@@ -58,7 +58,7 @@ open class Weighted<T>(
      * the closest target is picked.
      */
     override fun computeTarget(actions: List<SteeringAction<T, Euclidean2DPosition>>): Euclidean2DPosition =
-        environment.getPosition(node).let { currPos ->
+        environment.getCurrentPosition(node).let { currPos ->
             actions
                 .filterIsInstance<SteeringActionWithTarget<T, out Euclidean2DPosition>>()
                 .map { it.target() }
diff --git a/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestFeelsTransmission.kt b/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestFeelsTransmission.kt
index 6e4d1478f2..00b94a83ab 100644
--- a/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestFeelsTransmission.kt
+++ b/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestFeelsTransmission.kt
@@ -61,7 +61,7 @@ class TestFeelsTransmission<T> {
                 val reference = environment.makePosition(-50.0, 0.0)
                 environment.nodes.forEach {
                     assertTrue(
-                        environment.getPosition(it).distanceTo(reference) < 13.0,
+                        environment.getCurrentPosition(it).distanceTo(reference) < 13.0,
                         "Node should have moved closer to the evacuation reference point",
                     )
                 }
diff --git a/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestOrientingBehavior.kt b/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestOrientingBehavior.kt
index 55b9b14e53..ededd28e44 100644
--- a/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestOrientingBehavior.kt
+++ b/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestOrientingBehavior.kt
@@ -46,7 +46,7 @@ class TestOrientingBehavior<T, P> :
             val target = environment.makePosition(*coords)
             environment.nodes
                 .orienting()
-                .forEach { p -> environment.getPosition(p).distanceTo(target) shouldBeLessThan tolerance }
+                .forEach { p -> environment.getCurrentPosition(p).distanceTo(target) shouldBeLessThan tolerance }
         }
 
         /**
@@ -69,7 +69,7 @@ class TestOrientingBehavior<T, P> :
                 steps = 500,
                 onceInitialized = { it.nodes.size shouldBe 1 },
                 atEachStep = { environment: Environment<T, P>, _, _, _ ->
-                    val currentPosition = environment.getPosition(environment.nodes.first())
+                    val currentPosition = environment.getCurrentPosition(environment.nodes.first())
                     previousPositions.add(currentPosition)
                     if (previousPositions.size == expectedSize) {
                         previousPositions.distinct() shouldNotBe 1
@@ -92,7 +92,9 @@ class TestOrientingBehavior<T, P> :
                     if (environment is Euclidean2DEnvironmentWithGraph<*, T, *, *>) {
                         val node = environment.nodes.first()
                         val waypointToSkip = environment.makePosition(70, 105)
-                        environment.getPosition(node).shouldNotBeIn(environment.graph.nodeContaining(waypointToSkip))
+                        environment.getCurrentPosition(
+                            node,
+                        ).shouldNotBeIn(environment.graph.nodeContaining(waypointToSkip))
                     }
                 },
                 whenFinished = { environment, _, _ -> assertPedestriansReached(environment, 1.0, 85, 80) },
@@ -133,7 +135,7 @@ class TestOrientingBehavior<T, P> :
                     if (environment is Euclidean2DEnvironmentWithGraph<*, T, *, *> && !corridorTaken) {
                         val node = environment.nodes.orienting().first()
                         val corridorToTake = environment.graph.nodeContaining(environment.makePosition(35.0, 31.0))
-                        corridorTaken = corridorToTake?.contains(environment.getPosition(node)) ?: false
+                        corridorTaken = corridorToTake?.contains(environment.getCurrentPosition(node)) ?: false
                     }
                 },
                 whenFinished = { environment, _, _ ->
diff --git a/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestSteeringBehaviors.kt b/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestSteeringBehaviors.kt
index 9cb273f54a..d7ce678ea6 100644
--- a/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestSteeringBehaviors.kt
+++ b/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/TestSteeringBehaviors.kt
@@ -36,12 +36,12 @@ class TestSteeringBehaviors<T, P> :
                 .startSimulation(
                     onceInitialized = { environment ->
                         environment.nodes.forEach {
-                            startDistances[it] = environment.getPosition(it).distanceTo(environment.origin)
+                            startDistances[it] = environment.getCurrentPosition(it).distanceTo(environment.origin)
                         }
                     },
                     whenFinished = { environment, _, _ ->
                         environment.nodes.forEach {
-                            endDistances[it] = environment.getPosition(it).distanceTo(environment.origin)
+                            endDistances[it] = environment.getCurrentPosition(it).distanceTo(environment.origin)
                         }
                     },
                 ).nodes
@@ -55,12 +55,12 @@ class TestSteeringBehaviors<T, P> :
                 .startSimulation(
                     onceInitialized = { e ->
                         e.nodes.forEach {
-                            startDistances[it] = e.getPosition(it).distanceTo(e.origin)
+                            startDistances[it] = e.getCurrentPosition(it).distanceTo(e.origin)
                         }
                     },
                     whenFinished = { e, _, _ ->
                         e.nodes.forEach {
-                            endDistances[it] = e.getPosition(it).distanceTo(e.origin)
+                            endDistances[it] = e.getCurrentPosition(it).distanceTo(e.origin)
                         }
                     },
                 ).nodes
@@ -73,7 +73,7 @@ class TestSteeringBehaviors<T, P> :
                 startSimulation(
                     atEachStep = { e, _, _, _ ->
                         e.nodes.forEach {
-                            nodesPositions[it]?.add(e.getPosition(it))
+                            nodesPositions[it]?.add(e.getCurrentPosition(it))
                         }
                     },
                 )
@@ -106,8 +106,12 @@ class TestSteeringBehaviors<T, P> :
                         .groupBy { it.asProperty<T, SocialProperty<T>>().group }
                         .values
                         .forEach {
-                            for (nodePos in it.map { node -> e.getPosition(node) }) {
-                                for (otherPos in (it.map { node -> e.getPosition(node) }.minusElement(nodePos))) {
+                            for (nodePos in it.map { node -> e.getCurrentPosition(node) }) {
+                                for (otherPos in (
+                                    it.map { node ->
+                                        e.getCurrentPosition(node)
+                                    }.minusElement(nodePos)
+                                    )) {
                                     nodePos.distanceTo(otherPos) shouldBeLessThan 4.0
                                 }
                             }
@@ -120,7 +124,7 @@ class TestSteeringBehaviors<T, P> :
         "nodes using separation behavior keep a distance to each other" {
             loadYamlSimulation<T, P>("separation.yml").startSimulation(
                 whenFinished = { e, _, _ ->
-                    with(e.nodes.map { e.getPosition(it) }) {
+                    with(e.nodes.map { e.getCurrentPosition(it) }) {
                         for (nodePos in this) {
                             for (otherPos in (this.minusElement(nodePos))) {
                                 nodePos.distanceTo(otherPos) shouldBeGreaterThan 6.0
@@ -136,7 +140,7 @@ class TestSteeringBehaviors<T, P> :
             loadYamlSimulation<T, P>("obstacle-avoidance.yml").startSimulation(
                 whenFinished = { e, _, _ ->
                     e.nodes.forEach {
-                        e.getPosition(it).distanceTo(e.makePosition(600.0, 240.0)) shouldBeLessThan 10.0
+                        e.getCurrentPosition(it).distanceTo(e.makePosition(600.0, 240.0)) shouldBeLessThan 10.0
                     }
                 },
                 steps = 26000,
diff --git a/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/properties/TestPhysicalPedestrians.kt b/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/properties/TestPhysicalPedestrians.kt
index 165c36bf02..7a49547048 100644
--- a/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/properties/TestPhysicalPedestrians.kt
+++ b/alchemist-cognitive-agents/src/test/kotlin/it/unibo/alchemist/model/cognitive/properties/TestPhysicalPedestrians.kt
@@ -22,7 +22,7 @@ class TestPhysicalPedestrians<T, P> :
             loadYamlSimulation<T, P>("pushing_behavior.yml").startSimulation(
                 steps = 35000,
                 whenFinished = { environment, _, _ ->
-                    environment.getPosition(environment.nodes.first()) shouldNotBe environment.makePosition(0, 0)
+                    environment.getCurrentPosition(environment.nodes.first()) shouldNotBe environment.makePosition(0, 0)
                 },
             )
         }
diff --git a/alchemist-euclidean-geometry/src/main/java/it/unibo/alchemist/model/linkingrules/ConnectionBeam.java b/alchemist-euclidean-geometry/src/main/java/it/unibo/alchemist/model/linkingrules/ConnectionBeam.java
index 88306ae8cf..5c984d3fac 100644
--- a/alchemist-euclidean-geometry/src/main/java/it/unibo/alchemist/model/linkingrules/ConnectionBeam.java
+++ b/alchemist-euclidean-geometry/src/main/java/it/unibo/alchemist/model/linkingrules/ConnectionBeam.java
@@ -84,10 +84,10 @@ public Neighborhood<T> computeNeighborhood(final Node<T> center, final Environme
             });
         }
         if (!normal.isEmpty()) {
-            final Euclidean2DPosition cp = environment.getPosition(center);
+            final Euclidean2DPosition cp = environment.getCurrentPosition(center);
             final List<Node<T>> neighs = normal.getNeighbors().stream()
                 .filter(neigh -> {
-                    final Euclidean2DPosition np = environment.getPosition(neigh);
+                    final Euclidean2DPosition np = environment.getCurrentPosition(neigh);
                     return !oenv.intersectsObstacle(cp, np) || projectedBeamOvercomesObstacle(cp, np);
                 })
                 .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
diff --git a/alchemist-euclidean-geometry/src/main/kotlin/it/unibo/alchemist/model/actions/FollowAtDistance.kt b/alchemist-euclidean-geometry/src/main/kotlin/it/unibo/alchemist/model/actions/FollowAtDistance.kt
index 0045b339b4..8a0b996f71 100644
--- a/alchemist-euclidean-geometry/src/main/kotlin/it/unibo/alchemist/model/actions/FollowAtDistance.kt
+++ b/alchemist-euclidean-geometry/src/main/kotlin/it/unibo/alchemist/model/actions/FollowAtDistance.kt
@@ -57,7 +57,7 @@ class FollowAtDistance<T>(
     override fun execute() {
         node.getConcentration(target)?.also {
             val targetPosition = it.toPosition(environment)
-            val currentPosition = environment.getPosition(node)
+            val currentPosition = environment.getCurrentPosition(node)
             var destination = targetPosition.surroundingPointAt(currentPosition - targetPosition, distance)
             if (currentPosition != destination) { // avoid "bouncing"
                 val currentSpeed =
diff --git a/alchemist-euclidean-geometry/src/main/kotlin/it/unibo/alchemist/model/movestrategies/RandomTarget.kt b/alchemist-euclidean-geometry/src/main/kotlin/it/unibo/alchemist/model/movestrategies/RandomTarget.kt
index 1c05197211..3e7eb26efe 100644
--- a/alchemist-euclidean-geometry/src/main/kotlin/it/unibo/alchemist/model/movestrategies/RandomTarget.kt
+++ b/alchemist-euclidean-geometry/src/main/kotlin/it/unibo/alchemist/model/movestrategies/RandomTarget.kt
@@ -44,7 +44,7 @@ class RandomTarget<T>(
         distanceDistribution: RealDistribution,
     ) : this(
         environment,
-        { environment.getPosition(node) },
+        { environment.getCurrentPosition(node) },
         { x, y -> environment.makePosition(x, y) },
         directionRng,
         distanceDistribution,
diff --git a/alchemist-graphql-surrogates/src/main/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/surrogates/EnvironmentSurrogate.kt b/alchemist-graphql-surrogates/src/main/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/surrogates/EnvironmentSurrogate.kt
index 6596954292..4364bc4014 100644
--- a/alchemist-graphql-surrogates/src/main/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/surrogates/EnvironmentSurrogate.kt
+++ b/alchemist-graphql-surrogates/src/main/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/surrogates/EnvironmentSurrogate.kt
@@ -72,7 +72,7 @@ data class EnvironmentSurrogate<T, P : Position<out P>>(
      * Returns a [NodeToPosMap] representing all nodes associated with their position.
      */
     @GraphQLDescription("A list of entries NodeId-Position")
-    fun nodeToPos(): NodeToPosMap = origin.nodes.associate { it.id to origin.getPosition(it) }.toNodeToPosMap()
+    fun nodeToPos(): NodeToPosMap = origin.nodes.associate { it.id to origin.getCurrentPosition(it) }.toNodeToPosMap()
 
     /**
      * Returns the neighborhood of the node with the given id.
diff --git a/alchemist-graphql/src/jvmTest/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/EnvironmentSurrogateTest.kt b/alchemist-graphql/src/jvmTest/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/EnvironmentSurrogateTest.kt
index d0c2a80c8a..6c6186b2b8 100644
--- a/alchemist-graphql/src/jvmTest/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/EnvironmentSurrogateTest.kt
+++ b/alchemist-graphql/src/jvmTest/kotlin/it/unibo/alchemist/boundary/graphql/schema/model/EnvironmentSurrogateTest.kt
@@ -37,7 +37,7 @@ class EnvironmentSurrogateTest<T, P> where T : Any, P : Position<P>, P : Vector<
             envWrapper.nodes.forEach { node ->
                 val nodeSurrogate = envSurrogate.nodeById(node.id)
                 checkNodeSurrogate(node, nodeSurrogate)
-                checkPositionSurrogate(envWrapper.getPosition(node), envSurrogate.nodeToPos()[node.id]!!)
+                checkPositionSurrogate(envWrapper.getCurrentPosition(node), envSurrogate.nodeToPos()[node.id]!!)
                 checkNeighborhood(envWrapper.getNeighborhood(node).current, envSurrogate.getNeighborhood(node.id))
             }
             // Test propagation of changes
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/AbstractConfigurableMoveNode.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/AbstractConfigurableMoveNode.java
index 5f1b47cd29..3c2b5450f6 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/AbstractConfigurableMoveNode.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/AbstractConfigurableMoveNode.java
@@ -104,7 +104,7 @@ public final P getNextPosition() {
         double maxWalk = speedSelectionStrategy.getNodeMovementLength(end);
         final Environment<T, P> environment = getEnvironment();
         final Node<T> node = getNode();
-        P curPos = environment.getPosition(node);
+        P curPos = environment.getCurrentPosition(node);
         if (curPos.distanceTo(end) <= maxWalk) {
             final P destination = end;
             end = targetSelectionStrategy.getTarget();
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/AbstractMoveNode.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/AbstractMoveNode.java
index 0ed5f19581..e11207ccee 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/AbstractMoveNode.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/AbstractMoveNode.java
@@ -78,7 +78,7 @@ public void execute() {
             } else {
                 environment.moveNodeToPosition(
                         getNode(),
-                        environment.getPosition(getNode()).plus(getNextPosition().getCoordinates())
+                        environment.getCurrentPosition(getNode()).plus(getNextPosition().getCoordinates())
                 );
             }
         }
@@ -116,7 +116,7 @@ protected final P getCurrentPosition() {
      * @return the position of the node
      */
     protected final P getNodePosition(final Node<T> n) {
-        return environment.getPosition(n);
+        return environment.getCurrentPosition(n);
     }
 
     /**
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/MoveForwardAndTeleport.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/MoveForwardAndTeleport.java
index 8d88531736..57fe36de11 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/MoveForwardAndTeleport.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/actions/MoveForwardAndTeleport.java
@@ -63,7 +63,7 @@ public MoveForwardAndTeleport<T, P> cloneAction(final Node<T> node, final Reacti
 
     @Override
     public P getNextPosition() {
-        final P cur = getEnvironment().getPosition(getNode());
+        final P cur = getEnvironment().getCurrentPosition(getNode());
         if (Double.isNaN(y)) {
             y = cur.getY();
         }
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ObstaclesBreakConnection.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ObstaclesBreakConnection.java
index 2508b44f2c..1b6acc8834 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ObstaclesBreakConnection.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/linkingrules/ObstaclesBreakConnection.java
@@ -45,15 +45,15 @@ public ObstaclesBreakConnection(final Double radius) {
     public Neighborhood<T> computeNeighborhood(final Node<T> center, final Environment<T, P> environment) {
         Neighborhood<T> normal = super.computeNeighborhood(center, environment);
         if (!normal.isEmpty() && environment instanceof final EnvironmentWithObstacles<?, T, P> environmentWithObstacles) {
-            final P centerPosition = environment.getPosition(center);
+            final P centerPosition = environment.getCurrentPosition(center);
             environmentWithObstacles.intersectsObstacle(
-                environmentWithObstacles.getPosition(center),
-                environmentWithObstacles.getPosition(center)
+                environmentWithObstacles.getCurrentPosition(center),
+                environmentWithObstacles.getCurrentPosition(center)
             );
             final Iterable<Node<T>> neighbors = StreamSupport.stream(normal.spliterator(), false)
                 .filter(node ->
                     !environmentWithObstacles
-                        .intersectsObstacle(centerPosition, environmentWithObstacles.getPosition(node))
+                        .intersectsObstacle(centerPosition, environmentWithObstacles.getCurrentPosition(node))
                 )
                 .collect(Collectors.toList());
             normal = Neighborhoods.make(environmentWithObstacles, center, neighbors);
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
index 083e186b60..708e51a1fc 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
@@ -251,7 +251,8 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         return initialNodes
     }
 
-    override fun getDistanceBetweenNodes(n1: Node<T>, n2: Node<T>): Double = getPosition(n1).distanceTo(getPosition(n2))
+    override fun getDistanceBetweenNodes(n1: Node<T>, n2: Node<T>): Double =
+        retrievePosition(n1).distanceTo(retrievePosition(n2))
 
     override fun getLayer(molecule: Molecule): Layer<T, P>? = layers[molecule]
 
@@ -281,7 +282,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
     override fun getNodeByID(id: Int): Node<T> = nodes.first { n: Node<T> -> n.id == id }
 
     override fun getNodesWithinRange(node: Node<T>, range: Double): ListSet<Node<T>> {
-        val centerPosition = getPosition(node)
+        val centerPosition = retrievePosition(node)
         val res = LinkedListSet(getAllNodesInRange(centerPosition, range))
         check(res.remove(node)) {
             "Either the provided range ($range) is too small for queries to work without precision loss, " +
@@ -299,12 +300,12 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
     }
 
     override fun observeNodesWithinRange(node: Node<T>, range: Double): ObservableSet<Node<T>> =
-        observeAllNodesInRange({ getPosition(node) }, range, node)
+        observeAllNodesInRange({ retrievePosition(node) }, range, node)
 
     override fun observeNodesWithinRange(position: P, range: Double): ObservableSet<Node<T>> =
         observeAllNodesInRange({ position }, range)
 
-    override fun getPosition(node: Node<T>): P = requireNotNull(nodeToPos[node.id]) {
+    protected fun retrievePosition(node: Node<T>): P = requireNotNull(nodeToPos[node.id]) {
         check(!nodes.contains(node)) {
             "Node $node is registered in the environment but has no position. " +
                 "This could be a bug in Alchemist. Please open an issue at: " +
@@ -313,7 +314,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         "Node $node: ${node.javaClass.simpleName} does not exist in the environment."
     }
 
-    override fun observePosition(node: Node<T>): Observable<P> = observableNodeToPos[node.id].map { maybePosition ->
+    override fun getPosition(node: Node<T>): Observable<P> = observableNodeToPos[node.id].map { maybePosition ->
         val position = maybePosition.getOrNull()
         requireNotNull(position) {
             check(!nodes.contains(node)) {
@@ -446,7 +447,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
 
     private fun runQuery(center: P, range: Double): List<Node<T>> = spatialIndex
         .query(*center.boundingBox(range).map { it.coordinates }.toTypedArray())
-        .filter { getPosition(it).distanceTo(center) <= range }
+        .filter { retrievePosition(it).distanceTo(center) <= range }
 
     /**
      * Adds or updates a node's position in the position map.
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/movestrategies/target/FollowTarget.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/movestrategies/target/FollowTarget.kt
index e0a0667bdf..510359e598 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/movestrategies/target/FollowTarget.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/movestrategies/target/FollowTarget.kt
@@ -42,7 +42,7 @@ open class FollowTarget<T, P : Position<P>>(
     /**
      * the current position.
      */
-    protected val currentPosition: P get() = environment.getPosition(node)
+    protected val currentPosition: P get() = environment.getCurrentPosition(node)
 
     override fun getTarget(): P {
         val conc = node.getConcentration(targetMolecule) ?: return currentPosition
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/terminators/StableForSteps.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/terminators/StableForSteps.kt
index b84b1a828c..6e19bbe6be 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/terminators/StableForSteps.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/terminators/StableForSteps.kt
@@ -55,7 +55,7 @@ data class StableForSteps<T : Any, P : Position<P>>(private val checkInterval: L
 
     override fun invoke(environment: Environment<T, P>): Boolean {
         if (environment.simulation.step % checkInterval == 0L) {
-            val newPositions = environment.associateBy({ it }, { environment.getPosition(it) })
+            val newPositions = environment.associateBy({ it }, { environment.getCurrentPosition(it) })
             val newContents = makeTable<T>(environment.nodeCount.current)
             environment.forEach { node ->
                 node.contents.forEach { (molecule, concentration) ->
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/CellTensionPolarization.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/CellTensionPolarization.java
index 6499cd158c..0f9d10aa7a 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/CellTensionPolarization.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/CellTensionPolarization.java
@@ -71,7 +71,7 @@ public CellTensionPolarization cloneAction(final Node<Double> node, final Reacti
     @Override
     public void execute() {
         // get node position as an array
-        final double[] nodePosistion = environment.getPosition(getNode()).getCoordinates();
+        final double[] nodePosistion = environment.getCurrentPosition(getNode()).getCoordinates();
         // initializing resulting versor
         final double[] resultingVersor = new double[nodePosistion.length];
         // declaring a variable for the node where this action is set, to have faster access
@@ -102,7 +102,7 @@ public void execute() {
                 })
                 .map(node -> {
                     // position of node n as an array
-                    final double[] nPos = environment.getPosition(node).getCoordinates();
+                    final double[] nPos = environment.getCurrentPosition(node).getCoordinates();
                     // max radius of n
                     final double localNodeMaxRadius;
                     // min radius of n
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChemotacticPolarization.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChemotacticPolarization.java
index f64f090b6c..2b4d22f9c7 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChemotacticPolarization.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/actions/ChemotacticPolarization.java
@@ -111,9 +111,9 @@ public void execute() {
         if (l.isEmpty()) {
             cell.addPolarizationVersor(Euclidean2DPosition.Companion.getZero());
         } else {
-            final boolean isNodeOnMaxConc = environment.getPosition(l.stream()
+            final boolean isNodeOnMaxConc = environment.getCurrentPosition(l.stream()
                     .max(Comparator.comparingDouble(n -> n.getConcentration(biomolecule)))
-                    .get()).equals(environment.getPosition(thisNode));
+                    .get()).equals(environment.getCurrentPosition(thisNode));
             if (isNodeOnMaxConc) {
                 cell.addPolarizationVersor(environment.makePosition(0, 0));
             } else {
@@ -138,9 +138,9 @@ public void execute() {
 
     private Euclidean2DPosition weightedAverageVectors(final List<Node<Double>> list, final Node<Double> thisNode) {
         Euclidean2DPosition res = Euclidean2DPosition.Companion.getZero();
-        final Euclidean2DPosition thisNodePos = environment.getPosition(thisNode);
+        final Euclidean2DPosition thisNodePos = environment.getCurrentPosition(thisNode);
         for (final Node<Double> n : list) {
-            final Euclidean2DPosition nPos = environment.getPosition(n);
+            final Euclidean2DPosition nPos = environment.getCurrentPosition(n);
             Euclidean2DPosition vecTemp = new Euclidean2DPosition(
                 nPos.getX() - thisNodePos.getX(),
                 nPos.getY() - thisNodePos.getY()
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java
index 8b5b488a94..958d2b8349 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/conditions/BiomolPresentInEnv.java
@@ -85,7 +85,7 @@ private void setUpObservability() {
 
     private Observable<Double> observeTotalQuantity() {
         return environment.getNeighborhood(getNode()).mergeWith(
-            environment.observePosition(getNode()),
+            environment.getPosition(getNode()),
             (neighborhood, position) -> {
                 final double quantityInEnvNodes = neighborhood.getNeighbors().stream()
                     .parallel()
diff --git a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironmentNoOverlap.java b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironmentNoOverlap.java
index dc72f92278..379defe8be 100644
--- a/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironmentNoOverlap.java
+++ b/alchemist-incarnation-biochemistry/src/main/java/it/unibo/alchemist/model/biochemistry/environments/BioRect2DEnvironmentNoOverlap.java
@@ -84,7 +84,7 @@ protected boolean nodeShouldBeAdded(@Nonnull final Node<Double> node, @Nonnull f
                 return range <= 0
                         || getNodesWithinRange(position, range).stream()
                             .filter(n -> n.asPropertyOrNull(CircularCellProperty.class) != null)
-                            .noneMatch(n -> getPosition(n).distanceTo(position) < nodeRadius
+                            .noneMatch(n -> retrievePosition(n).distanceTo(position) < nodeRadius
                                     + n.asProperty(CircularCellProperty.class).getRadius());
             } else {
                 return true;
@@ -96,7 +96,7 @@ protected boolean nodeShouldBeAdded(@Nonnull final Node<Double> node, @Nonnull f
 
     @Override
     public void moveNodeToPosition(@Nonnull final Node<Double> node, @Nonnull final Euclidean2DPosition newPosition) {
-        final double[] cur = getPosition(node).getCoordinates();
+        final double[] cur = retrievePosition(node).getCoordinates();
         final double[] np = newPosition.getCoordinates();
         final Euclidean2DPosition nextWithinLimts = super.next(cur[0], cur[1], np[0], np[1]);
         if (node.asPropertyOrNull(CircularCellProperty.class) != null) {
@@ -158,7 +158,7 @@ private Euclidean2DPosition findNearestFreePosition(
         range = FastMath.sqrt(FastMath.pow(newHalfDistance, 2) + FastMath.pow(newMaxDiameter, 2));
         return getNodesWithinRange(newMidPoint, range).stream()
                 .filter(n -> !n.equals(nodeToMove) && n.asPropertyOrNull(CircularCellProperty.class) != null)
-                .filter(n -> selectNodes(n, nodeToMove, getPosition(nodeToMove), requestedPos, xVer, yVer))
+                .filter(n -> selectNodes(n, nodeToMove, retrievePosition(nodeToMove), requestedPos, xVer, yVer))
                 .map(n -> getPositionIfNodeIsObstacle(nodeToMove, n, originalPos, oy, ox, ry, rx))
                 .filter(Optional::isPresent)
                 .map(Optional::get)
@@ -175,7 +175,7 @@ private boolean selectNodes(
         final double yVer
     ) {
         // testing if node is between requested position and original position
-        final Euclidean2DPosition nodePos = getPosition(node);
+        final Euclidean2DPosition nodePos = retrievePosition(node);
         final Euclidean2DPosition nodeOrientationFromOrigin = new Euclidean2DPosition(nodePos.getX() - origin.getX(),
                 nodePos.getY() - origin.getY());
         final double scalarProductResult1 = xVer * nodeOrientationFromOrigin.getX()
@@ -208,7 +208,7 @@ private Optional<Euclidean2DPosition> getPositionIfNodeIsObstacle(
         final double xr
     ) {
         // original position
-        final Euclidean2DPosition possibleObstaclePosition = getPosition(node);
+        final Euclidean2DPosition possibleObstaclePosition = retrievePosition(node);
         // coordinates of original position, requested position and of node's position
         final double yn = possibleObstaclePosition.getY();
         final double xn = possibleObstaclePosition.getX();
diff --git a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/actions/TestChemotaxis.java b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/actions/TestChemotaxis.java
index a0771cd57d..1d99185018 100644
--- a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/actions/TestChemotaxis.java
+++ b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/actions/TestChemotaxis.java
@@ -243,7 +243,7 @@ void testChemotacticMove1() {
         r1.execute();
         r2.execute();
         assertEquals(new Euclidean2DPosition(0.5 + FastMath.sqrt(0.5), 0.5 + FastMath.sqrt(0.5)),
-                environment.getPosition(cellNode1)
+                environment.getCurrentPosition(cellNode1)
         );
     }
 
@@ -273,11 +273,11 @@ void testChemotacticMove2() {
         r1.execute();
         r2.execute();
         assertEquals(1,
-                environment.getPosition(cellNode1).getX(),
+                environment.getCurrentPosition(cellNode1).getX(),
                 PRECISION
                 );
         assertEquals(1,
-                environment.getPosition(cellNode1).getY(),
+                environment.getCurrentPosition(cellNode1).getY(),
                 PRECISION
                 );
     }
@@ -310,11 +310,11 @@ void testChemotacticMove3() {
         r2.execute();
         r2.execute();
         assertEquals(0.5,
-                environment.getPosition(cellNode1).getX(),
+                environment.getCurrentPosition(cellNode1).getX(),
                 PRECISION
                 );
         assertEquals(0.5,
-                environment.getPosition(cellNode1).getY(),
+                environment.getCurrentPosition(cellNode1).getY(),
                 PRECISION
                 );
     }
diff --git a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/environments/TestBioRect2DEnvironmentNoOverlap.java b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/environments/TestBioRect2DEnvironmentNoOverlap.java
index 9f84dcf365..a89753cbcf 100644
--- a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/environments/TestBioRect2DEnvironmentNoOverlap.java
+++ b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/environments/TestBioRect2DEnvironmentNoOverlap.java
@@ -172,7 +172,7 @@ void testAddNode() {
 
         final Euclidean2DPosition p3 = new Euclidean2DPosition(0, 20); // this should be added
         environment.addNode(n3, p3);
-        assertEquals(environment.getPosition(n3), p3, getFailureTestString("n3", n3, p3));
+        assertEquals(environment.getCurrentPosition(n3), p3, getFailureTestString("n3", n3, p3));
         environment.removeNode(n3);
         final Euclidean2DPosition p4 = new Euclidean2DPosition(0, 10); // this should be added
         environment.addNode(n4, p4);
@@ -209,7 +209,7 @@ private void verifyNotAdded(final Node<Double> node) {
     }
 
     private void verifyAdded(final Node<Double> node, @Nonnull final Position<?> expected) {
-        final Position<?> position = environment.getPosition(node);
+        final Position<?> position = environment.getCurrentPosition(node);
         final Supplier<String> message = () -> getFailureTestString("node" + node.getId(), node, position);
         assertEquals(expected, position, message);
     }
@@ -227,8 +227,8 @@ void testMoveNode1() {
         environment.moveNode(cellToMove1, POSITION_TO_MOVE1);
         assertEquals(
             EXPECTED_POS1,
-            environment.getPosition(cellToMove1),
-                "cellToMove1 is in position: " + environment.getPosition(cellToMove1)
+            environment.getCurrentPosition(cellToMove1),
+                "cellToMove1 is in position: " + environment.getCurrentPosition(cellToMove1)
         );
         environment.removeNode(cellToMove1);
         environment.removeNode(c1);
@@ -250,8 +250,8 @@ void testMoveNode2() {
         environment.moveNode(cellToMove2, POSITION_TO_MOVE2);
         assertEquals(
             EXPECTED_POS2,
-            environment.getPosition(cellToMove2),
-                "cellToMove2 is in position: " + environment.getPosition(cellToMove2)
+            environment.getCurrentPosition(cellToMove2),
+                "cellToMove2 is in position: " + environment.getCurrentPosition(cellToMove2)
         );
         environment.removeNode(cellToMove2);
         environment.removeNode(c2);
@@ -270,9 +270,9 @@ void testMoveNode3() {
         environment.addNode(c4, p4);
         environment.moveNode(cellToMove3, POSITION_TO_MOVE3);
         assertEquals(
-                environment.getPosition(cellToMove3),
+                environment.getCurrentPosition(cellToMove3),
                 originalPos,
-                CELL_TO_MOVE_3_IS_IN_POSITION + environment.getPosition(cellToMove3)
+                CELL_TO_MOVE_3_IS_IN_POSITION + environment.getCurrentPosition(cellToMove3)
         );
         environment.removeNode(cellToMove3);
         environment.removeNode(c4);
@@ -295,8 +295,8 @@ void testMoveNode4() {
         environment.moveNode(cellToMove4, POSITION_TO_MOVE4);
         assertNotEquals(
             POSITION_TO_MOVE4,
-            environment.getPosition(cellToMove4),
-                CELL_TO_MOVE_4_IS_IN_POSITION + environment.getPosition(cellToMove4)
+            environment.getCurrentPosition(cellToMove4),
+                CELL_TO_MOVE_4_IS_IN_POSITION + environment.getCurrentPosition(cellToMove4)
         );
         environment.removeNode(cellToMove4);
         environment.removeNode(c5);
@@ -315,8 +315,8 @@ void testMoveNode5() {
         environment.moveNode(cellToMove5, POSITION_TO_MOVE5);
         assertEquals(
             POSITION_TO_MOVE5,
-            environment.getPosition(cellToMove5),
-                CELL_TO_MOVE_5_IS_IN_POSITION + environment.getPosition(cellToMove5)
+            environment.getCurrentPosition(cellToMove5),
+                CELL_TO_MOVE_5_IS_IN_POSITION + environment.getCurrentPosition(cellToMove5)
         );
         environment.removeNode(cellToMove5);
         environment.removeNode(c6);
@@ -335,8 +335,8 @@ void testMoveNode6() {
         environment.moveNode(cellToMove6, POSITION_TO_MOVE6);
         assertEquals(
             EXPECTED_POS6,
-            environment.getPosition(cellToMove6),
-                "cellToMove6 is in position: " + environment.getPosition(cellToMove6)
+            environment.getCurrentPosition(cellToMove6),
+                "cellToMove6 is in position: " + environment.getCurrentPosition(cellToMove6)
         );
         environment.removeNode(cellToMove6);
         environment.removeNode(c7);
@@ -353,8 +353,8 @@ void testMoveNode7() {
         final Node<Double> c8 = createNode(LITTLE_CELL_DIAMETER);
         environment.addNode(c8, p8);
         environment.moveNode(cellToMove7, POSITION_TO_MOVE7);
-        assertTrueJUnit4("cellToMove7 is in position: " + environment.getPosition(cellToMove7),
-                EXPECTED_POS7.equals(environment.getPosition(cellToMove7)));
+        assertTrueJUnit4("cellToMove7 is in position: " + environment.getCurrentPosition(cellToMove7),
+                EXPECTED_POS7.equals(environment.getCurrentPosition(cellToMove7)));
         environment.removeNode(cellToMove7);
         environment.removeNode(c8);
     }
@@ -370,8 +370,8 @@ void testMoveNode8() {
         final Node<Double> c9 = createNode(LITTLE_CELL_DIAMETER);
         environment.addNode(c9, p9);
         environment.moveNode(cellToMove8, POSITION_TO_MOVE8);
-        assertTrueJUnit4("cellToMove8 is in position: " + environment.getPosition(cellToMove8),
-                EXPECTED_POS8.equals(environment.getPosition(cellToMove8)));
+        assertTrueJUnit4("cellToMove8 is in position: " + environment.getCurrentPosition(cellToMove8),
+                EXPECTED_POS8.equals(environment.getCurrentPosition(cellToMove8)));
         environment.removeNode(cellToMove8);
         environment.removeNode(c9);
     }
@@ -413,14 +413,14 @@ void testAddDifferentDiam2() {
         nodeNotInEnvironment(environment, ng1);
         assertTrueJUnit4(
             getFailureTestString("ng2", ng2, p2),
-            environment.getPosition(ng2).equals(p2)
+            environment.getCurrentPosition(ng2).equals(p2)
         );
         nodeNotInEnvironment(environment, ng3);
         environment.removeNode(ng2);
         environment.addNode(ng3, p3);
         assertTrueJUnit4(
             getFailureTestString("ng3", ng3, p3),
-            environment.getPosition(ng3).equals(p3)
+            environment.getCurrentPosition(ng3).equals(p3)
         );
     }
 
@@ -439,11 +439,11 @@ void testAddDifferentDiam3() {
         environment.addNode(np2, p3);
         assertTrueJUnit4(
             getFailureTestString("ng1", ng1, p1),
-            environment.getPosition(ng1).equals(p1)
+            environment.getCurrentPosition(ng1).equals(p1)
         );
         assertTrueJUnit4(
             getFailureTestString("nm1", nm1, p2),
-            environment.getPosition(nm1).equals(p2)
+            environment.getCurrentPosition(nm1).equals(p2)
         );
         nodeNotInEnvironment(environment, nm2);
         nodeNotInEnvironment(environment, np2);
@@ -461,8 +461,8 @@ void testMoveDifferentDiam1() {
         final Euclidean2DPosition p1 = new Euclidean2DPosition(25, 20);
         environment.addNode(ng1, p1);
         environment.moveNode(cellToMove1, pd);
-        assertTrueJUnit4("cellToMove1 is in position: " + environment.getPosition(cellToMove1),
-                environment.getPosition(cellToMove1).equals(pd));
+        assertTrueJUnit4("cellToMove1 is in position: " + environment.getCurrentPosition(cellToMove1),
+                environment.getCurrentPosition(cellToMove1).equals(pd));
     }
 
     /**
@@ -477,8 +477,8 @@ void testMoveDifferentDiam2() {
         final Euclidean2DPosition p2 = new Euclidean2DPosition(25, 30);
         environment.addNode(bce, p2);
         environment.moveNode(cellToMove2, pd);
-        assertTrueJUnit4("cellToMove2 is in position: " + environment.getPosition(cellToMove2),
-                environment.getPosition(cellToMove2).equals(pd));
+        assertTrueJUnit4("cellToMove2 is in position: " + environment.getCurrentPosition(cellToMove2),
+                environment.getCurrentPosition(cellToMove2).equals(pd));
     }
 
     /**
@@ -494,15 +494,15 @@ void testMoveDifferentDiam3() {
         environment.addNode(ng1, p1);
         environment.moveNode(cellToMove3, pd);
         assertTrueJUnit4(
-            CELL_TO_MOVE_3_IS_IN_POSITION + environment.getPosition(cellToMove3),
-            EXPECTED_POS_DIFFDIAM3_1.equals(environment.getPosition(cellToMove3))
+            CELL_TO_MOVE_3_IS_IN_POSITION + environment.getCurrentPosition(cellToMove3),
+            EXPECTED_POS_DIFFDIAM3_1.equals(environment.getCurrentPosition(cellToMove3))
         );
         environment.removeNode(ng1);
         environment.addNode(nm1, p1);
         environment.moveNode(cellToMove3, pd);
         assertTrueJUnit4(
-            CELL_TO_MOVE_3_IS_IN_POSITION + environment.getPosition(cellToMove3),
-            EXPECTED_POS_DIFFDIAM3_2.equals(environment.getPosition(cellToMove3))
+            CELL_TO_MOVE_3_IS_IN_POSITION + environment.getCurrentPosition(cellToMove3),
+            EXPECTED_POS_DIFFDIAM3_2.equals(environment.getCurrentPosition(cellToMove3))
         );
     }
 
@@ -519,15 +519,15 @@ void testMoveDifferentDiam4() {
         environment.addNode(ng1, p1);
         environment.moveNode(cellToMove4, pd);
         assertTrueJUnit4(
-            CELL_TO_MOVE_4_IS_IN_POSITION + environment.getPosition(cellToMove4),
-            EXPECTED_POS_DIFFDIAM4_1.equals(environment.getPosition(cellToMove4))
+            CELL_TO_MOVE_4_IS_IN_POSITION + environment.getCurrentPosition(cellToMove4),
+            EXPECTED_POS_DIFFDIAM4_1.equals(environment.getCurrentPosition(cellToMove4))
         );
         environment.removeNode(ng1);
         environment.addNode(nm1, p1);
         environment.moveNode(cellToMove4, pd);
         assertTrueJUnit4(
-            CELL_TO_MOVE_4_IS_IN_POSITION + environment.getPosition(cellToMove4),
-            EXPECTED_POS_DIFFDIAM4_2.equals(environment.getPosition(cellToMove4))
+            CELL_TO_MOVE_4_IS_IN_POSITION + environment.getCurrentPosition(cellToMove4),
+            EXPECTED_POS_DIFFDIAM4_2.equals(environment.getCurrentPosition(cellToMove4))
         );
     }
 
@@ -544,17 +544,17 @@ void testMoveDifferentDiam5() {
         environment.addNode(ng1, p1);
         environment.moveNode(cellToMove5, pd);
         assertNotEquals(
-                environment.getPosition(cellToMove5),
+                environment.getCurrentPosition(cellToMove5),
                 pd,
-                CELL_TO_MOVE_5_IS_IN_POSITION + environment.getPosition(cellToMove5)
+                CELL_TO_MOVE_5_IS_IN_POSITION + environment.getCurrentPosition(cellToMove5)
         );
         environment.removeNode(ng1);
         environment.addNode(nm1, p1);
         environment.moveNode(cellToMove5, pd);
         assertNotEquals(
-                environment.getPosition(cellToMove5),
+                environment.getCurrentPosition(cellToMove5),
                 pd,
-                CELL_TO_MOVE_5_IS_IN_POSITION + environment.getPosition(cellToMove5)
+                CELL_TO_MOVE_5_IS_IN_POSITION + environment.getCurrentPosition(cellToMove5)
         );
     }
 
@@ -573,8 +573,8 @@ void testMoveDifferentDiam6() {
         environment.addNode(np2, p2);
         environment.moveNode(cellToMove6, pd);
         assertTrueJUnit4(
-                "cellToMove6 is in position: " + environment.getPosition(cellToMove6),
-                environment.getPosition(cellToMove6).equals(pd)
+                "cellToMove6 is in position: " + environment.getCurrentPosition(cellToMove6),
+                environment.getCurrentPosition(cellToMove6).equals(pd)
         );
     }
 
@@ -592,8 +592,8 @@ void testMoveDifferentDiam7() {
         final Euclidean2DPosition p2 = new Euclidean2DPosition(60, 5);
         environment.addNode(np2, p2);
         environment.moveNode(cellToMove7, pd);
-        assertTrueJUnit4("cellToMove7 is in position: " + environment.getPosition(cellToMove7),
-                environment.getPosition(cellToMove7).equals(pd));
+        assertTrueJUnit4("cellToMove7 is in position: " + environment.getCurrentPosition(cellToMove7),
+                environment.getCurrentPosition(cellToMove7).equals(pd));
     }
 
     /**
@@ -610,8 +610,8 @@ void testMoveDifferentDiam8() {
         final Euclidean2DPosition p2 = new Euclidean2DPosition(0, 10);
         environment.addNode(np2, p2);
         environment.moveNode(cellToMove8, pd);
-        assertTrueJUnit4("cellToMove8 is in position: " + environment.getPosition(cellToMove8),
-                environment.getPosition(cellToMove8).equals(pd));
+        assertTrueJUnit4("cellToMove8 is in position: " + environment.getCurrentPosition(cellToMove8),
+                environment.getCurrentPosition(cellToMove8).equals(pd));
     }
 
     /**
@@ -628,10 +628,14 @@ void testMoveInTwoSteps1() {
         final Node<Double> c2 = np2;
         environment.addNode(c2, pd1);
         environment.moveNode(c1, POSITION_TO_MOVE_TWOSTEP1);
-        assertEquals(EXPECTED_POS_TWOSTEP1_1, environment.getPosition(c1), "c1 is in pos : " + environment.getPosition(c1));
+        assertEquals(
+            EXPECTED_POS_TWOSTEP1_1, environment.getCurrentPosition(c1), "c1 is in pos : " + environment.getCurrentPosition(c1)
+        );
         environment.moveNode(c2, pd1);
         environment.moveNodeToPosition(c1, pd2);
-        assertEquals(EXPECTED_POS_TWOSTEP1_2, environment.getPosition(c1), "c1 is in pos : " + environment.getPosition(c1));
+        assertEquals(
+            EXPECTED_POS_TWOSTEP1_2, environment.getCurrentPosition(c1), "c1 is in pos : " + environment.getCurrentPosition(c1)
+        );
 
     }
 
@@ -646,7 +650,7 @@ void testMoveNode9() {
         environment.addNode(c1, originalPos);
         final Euclidean2DPosition pd = new Euclidean2DPosition(4.737000465393066, -5.0);
         environment.moveNode(c1, pd);
-        assertNotEquals(environment.getPosition(c1), pd);
+        assertNotEquals(environment.getCurrentPosition(c1), pd);
     }
 
     /**
@@ -660,7 +664,7 @@ void testMoveNode10() {
         environment.addNode(c1, originalPos);
         final Euclidean2DPosition pd = new Euclidean2DPosition(3.122374292470004, -0.6490462479722794);
         environment.moveNode(c1, pd);
-        assertNotEquals(environment.getPosition(c1), pd);
+        assertNotEquals(environment.getCurrentPosition(c1), pd);
     }
 
     private List<Node<Double>> getOverlappingNodes(final Node<Double> node) {
@@ -671,7 +675,7 @@ private List<Node<Double>> getOverlappingNodes(final Node<Double> node) {
     }
 
     private List<String> mapToNodePositions(final List<Node<Double>> nodes) {
-        return nodes.stream().map(node -> environment.getPosition(node).toString()).collect(Collectors.toList());
+        return nodes.stream().map(node -> environment.getCurrentPosition(node).toString()).collect(Collectors.toList());
     }
 
     /**
@@ -810,8 +814,8 @@ private boolean thereIsOverlap(final Environment<Double, Euclidean2DPosition> en
                     .findAny()
                     .ifPresent(e ->
                         fail(
-                            "Nodes " + e.getFirst().getId() + env.getPosition(e.getFirst()) + " and "
-                                + e.getSecond().getId() + env.getPosition(e.getSecond()) + " are overlapping. "
+                            "Nodes " + e.getFirst().getId() + env.getCurrentPosition(e.getFirst()) + " and "
+                                + e.getSecond().getId() + env.getCurrentPosition(e.getSecond()) + " are overlapping. "
                                 + "Their distance is: " + env.getDistanceBetweenNodes(e.getFirst(), e.getSecond())
                                 + " but should be greater than "
                                 + (
@@ -831,7 +835,7 @@ private boolean thereIsOverlap(final Environment<Double, Euclidean2DPosition> en
     }
 
     private String getFailureTestString(final String nodeName, final Node<Double> n, final Position<?> expected) {
-        return nodeName + " not in pos " + expected + "; it's in pos " + environment.getPosition(n);
+        return nodeName + " not in pos " + expected + "; it's in pos " + environment.getCurrentPosition(n);
     }
 
     private static <T> void nodeNotInEnvironment(final Environment<T, ?> environment, final Node<T> node) {
@@ -846,12 +850,12 @@ private static <T> void checkNodeInEnvironment(
         final var isInEnvironment = environment.getNodes().contains(node);
         if (shouldBePresent) {
             assertTrue(isInEnvironment, () -> NODE + node + " is not in the environment");
-            final var position = environment.getPosition(node);
+            final var position = environment.getCurrentPosition(node);
             assertNotNull(position, () -> NODE + node + " has no valid position");
         } else {
             assertFalse(
                 isInEnvironment,
-                () -> NODE + node + " is in the environment at position " + environment.getPosition(node)
+                () -> NODE + node + " is in the environment at position " + environment.getCurrentPosition(node)
             );
         }
     }
diff --git a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/layers/TestBiomolLayer.java b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/layers/TestBiomolLayer.java
index 064086ce72..e6630eb53f 100644
--- a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/layers/TestBiomolLayer.java
+++ b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/layers/TestBiomolLayer.java
@@ -86,7 +86,7 @@ public void stepDone(
                 @Nonnull final Time time,
                 final long step
             ) {
-                final Euclidean2DPosition curPos = environment.getPosition(environment.getNodeByID(0));
+                final Euclidean2DPosition curPos = environment.getCurrentPosition(environment.getNodeByID(0));
                 assertEquals(curPos.getX() > 0 && curPos.getY() > 0, underTest.canExecute());
             }
 
diff --git a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/nodes/TestEnvironmentNodes.java b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/nodes/TestEnvironmentNodes.java
index d03f3bd801..8368252299 100644
--- a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/nodes/TestEnvironmentNodes.java
+++ b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/nodes/TestEnvironmentNodes.java
@@ -237,7 +237,9 @@ void testEnv2() {
             .parallel()
             .filter(n -> n.getClass().equals(EnvironmentNodeImpl.class))
             .min(
-                Comparator.comparingDouble(n -> environment.getPosition(n).distanceTo(environment.getPosition(center)))
+                Comparator.comparingDouble(n ->
+                    environment.getCurrentPosition(n).distanceTo(environment.getCurrentPosition(center))
+                )
             )
             .map(node -> node.getConcentration(new Biomolecule(A)))
             .orElseThrow();
@@ -295,13 +297,13 @@ void testEnv5() {
         final Environment<Double, Euclidean2DPosition> environment = testNoVar("testEnv5.yml");
         final double conAInEnv1 = environment.getNodes().stream()
             .parallel()
-            .filter(n -> environment.getPosition(n).equals(new Euclidean2DPosition(0, 0)))
+            .filter(n -> environment.getCurrentPosition(n).equals(new Euclidean2DPosition(0, 0)))
             .findAny()
             .map(node -> node.getConcentration(new Biomolecule(A)))
             .orElseThrow();
         final double conAInEnv2 = environment.getNodes().stream()
             .parallel()
-            .filter(n -> environment.getPosition(n).equals(new Euclidean2DPosition(1, 0)))
+            .filter(n -> environment.getCurrentPosition(n).equals(new Euclidean2DPosition(1, 0)))
             .findAny()
             .map(node -> node.getConcentration(new Biomolecule(A)))
             .orElseThrow();
diff --git a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/properties/TestDeformableCell.java b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/properties/TestDeformableCell.java
index d06cbaf9a9..5d2a4baea2 100644
--- a/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/properties/TestDeformableCell.java
+++ b/alchemist-incarnation-biochemistry/src/test/java/it/unibo/alchemist/model/biochemistry/properties/TestDeformableCell.java
@@ -113,8 +113,12 @@ void testAddNode1() {
         environment.addNode(cellNode3, CELL_POS1_3);
         environment.addNode(cellNode4, CELL_POS1_4);
 
-        assertNotNull(environment.getPosition(cellNode2), "Position of cellNode2 = " + environment.getPosition(cellNode2));
-        assertNotNull(environment.getPosition(cellNode3), "Position of cellNode3 = " + environment.getPosition(cellNode3));
+        assertNotNull(
+            environment.getCurrentPosition(cellNode2), "Position of cellNode2 = " + environment.getCurrentPosition(cellNode2)
+        );
+        assertNotNull(
+            environment.getCurrentPosition(cellNode3), "Position of cellNode3 = " + environment.getCurrentPosition(cellNode3)
+        );
         assertFalse(environment.getNodes().contains(cellNode4), "unexpected node in the environment");
     }
 
@@ -391,8 +395,8 @@ void testMoveNode1() {
         environment.moveNodeToPosition(cellNode1, new Euclidean2DPosition(0, 10));
         assertEquals(
             EXPECTED_POS_MOV1,
-            environment.getPosition(cellNode1),
-                "Position of cellNode1 = " + environment.getPosition(cellNode1)
+            environment.getCurrentPosition(cellNode1),
+                "Position of cellNode1 = " + environment.getCurrentPosition(cellNode1)
         );
     }
 }
diff --git a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/AlchemistExecutionContext.kt b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/AlchemistExecutionContext.kt
index 51376a3d71..e1b2b361b9 100644
--- a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/AlchemistExecutionContext.kt
+++ b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/AlchemistExecutionContext.kt
@@ -94,7 +94,7 @@ class AlchemistExecutionContext<P : Position<P>>(
      * The device position, in form of [Position].
      */
     val devicePosition: P
-        get() = environmentAccess.getPosition(node)
+        get() = environmentAccess.getCurrentPosition(node)
 
     /**
      * @param environment
@@ -243,7 +243,8 @@ class AlchemistExecutionContext<P : Position<P>>(
      * the destination, in the form of a destination node
      * @return the distance on a map
      */
-    fun routingDistance(dest: Node<Any>): Double = routingDistance(environmentAccess.getPosition(dest) as GeoPosition)
+    fun routingDistance(dest: Node<Any>): Double =
+        routingDistance(environmentAccess.getCurrentPosition(dest) as GeoPosition)
 
     /**
      * Computes the distance along a map. Requires a [MapEnvironment].
diff --git a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/properties/ProtelisDevice.kt b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/properties/ProtelisDevice.kt
index ed13f7fcdb..55ff5853c1 100644
--- a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/properties/ProtelisDevice.kt
+++ b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/protelis/properties/ProtelisDevice.kt
@@ -128,7 +128,7 @@ constructor(
         when {
             node.contains(molecule) -> node.getConcentration(molecule)
             else ->
-                checkNotNull(environment.getLayer(molecule)?.getValue(environment.getPosition(node))) {
+                checkNotNull(environment.getLayer(molecule)?.getValue(environment.getCurrentPosition(node))) {
                     "Molecule (variable) \"$id\" not found in $this, nor a layer with the same name exists"
                 }
         }
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPEREMoveNodeAgent.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPEREMoveNodeAgent.java
index dbc2fa2344..54d0d63a6e 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPEREMoveNodeAgent.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPEREMoveNodeAgent.java
@@ -75,7 +75,7 @@ protected Environment<List<ILsaMolecule>, P> getEnvironment() {
      * @return the current position of the node
      */
     protected P getCurrentPosition() {
-        return environment.getPosition(getNode());
+        return environment.getCurrentPosition(getNode());
     }
 
     /**
@@ -84,7 +84,7 @@ protected P getCurrentPosition() {
      * @return the position of node
      */
     protected final P getPosition(final Node<List<ILsaMolecule>> node) {
-        return environment.getPosition(node);
+        return environment.getCurrentPosition(node);
     }
 
     /**
@@ -112,7 +112,7 @@ protected final void move(final P direction) {
         if (environment instanceof EuclideanEnvironment) {
             ((EuclideanEnvironment) environment).moveNode(getNode(), direction);
         } else {
-            final var myPosition = environment.getPosition(getNode());
+            final var myPosition = environment.getCurrentPosition(getNode());
             environment.moveNodeToPosition(getNode(), myPosition.plus(direction.getCoordinates()));
         }
     }
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPERENeighborAgent.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPERENeighborAgent.java
index 2aec35ab52..795a5b2f5e 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPERENeighborAgent.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/AbstractSAPERENeighborAgent.java
@@ -116,7 +116,7 @@ public final Context getContext() {
      * @return the current position of the node
      */
     protected final P getCurrentPosition() {
-        return environment.getPosition(getNode());
+        return environment.getCurrentPosition(getNode());
     }
 
     /**
@@ -125,7 +125,7 @@ protected final P getCurrentPosition() {
      * @return the position of node
      */
     protected final P getPosition(final ILsaNode node) {
-        return environment.getPosition(node);
+        return environment.getCurrentPosition(node);
     }
 
     /**
@@ -148,7 +148,10 @@ protected final Neighborhood<List<ILsaMolecule>> getLocalNeighborhood() {
      * @param direction the point towards which move the node
      */
     protected final void move(final P direction) {
-        environment.moveNodeToPosition(getNode(), getEnvironment().getPosition(getNode()).plus(direction.getCoordinates()));
+        environment.moveNodeToPosition(
+            getNode(),
+            getEnvironment().getCurrentPosition(getNode()).plus(direction.getCoordinates())
+        );
     }
 
     /**
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/SAPEREWalkerRiseGradient.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/SAPEREWalkerRiseGradient.java
index e7faa13f5f..9fe965203c 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/SAPEREWalkerRiseGradient.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/actions/SAPEREWalkerRiseGradient.java
@@ -148,7 +148,7 @@ public GeoPosition getTarget() {
              *
              * then remain still.
              */
-            final GeoPosition currentPosition = environment.getPosition(node);
+            final GeoPosition currentPosition = environment.getCurrentPosition(node);
             if (matches.isEmpty()) {
                 if (curPos == null || currentPosition.equals(curPos)) {
                     return currentPosition;
@@ -159,7 +159,7 @@ public GeoPosition getTarget() {
             /*
              * If the current target node has moved, the destination should be re-computed.
              */
-            final Position<?> curNodeActualPos = environment.getPosition(curNode);
+            final Position<?> curNodeActualPos = environment.getCurrentPosition(curNode);
             if (curNode.equals(node)
                 || !curPos.equals(curNodeActualPos)
                 || environment.getNeighborhood(node).getCurrent().contains(curNode)) {
@@ -167,7 +167,7 @@ public GeoPosition getTarget() {
                  * Update target
                  */
                 curNode = environment.getNodeByID(nid);
-                curPos = environment.getPosition(curNode);
+                curPos = environment.getCurrentPosition(curNode);
             }
             return curPos;
         }
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
index a838602775..53c3b6f827 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
@@ -391,11 +391,11 @@ protected void updateInternalStatus(
                 : getNode().getConcentration(context);
         final TIntObjectMap<P> positionCacheTemp = new TIntObjectHashMap<>(positionCache.size());
         final TIntObjectMap<List<? extends ILsaMolecule>> gradCacheTemp = new TIntObjectHashMap<>(gradCache.size());
-        final P curPos = this.environment.getPosition(getNode());
+        final P curPos = this.environment.getCurrentPosition(getNode());
         final boolean positionChanged = !curPos.equals(mypos);
         boolean neighPositionChanged = false;
         for (final Node<List<ILsaMolecule>> n : this.environment.getNeighborhood(getNode()).getCurrent()) {
-            final P p = this.environment.getPosition(n);
+            final P p = this.environment.getCurrentPosition(n);
             final int nid = n.getId();
             positionCacheTemp.put(nid, p);
             gradCacheTemp.put(n.getId(), n.getConcentration(gradient));
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java
index 38cf2023d6..30746d76fa 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREReaction.java
@@ -142,7 +142,7 @@ public void execute() {
             }
             return;
         }
-        final Position<?> nodePosCache = modifiesOnlyLocally ? environment.getPosition(getNode()) : null;
+        final Position<?> nodePosCache = modifiesOnlyLocally ? environment.getCurrentPosition(getNode()) : null;
         final List<? extends ILsaMolecule> localContentCache = modifiesOnlyLocally
             ? new ArrayList<>(getLsaNode().getLsaSpace())
             : null;
@@ -210,7 +210,7 @@ public void execute() {
          */
         if (modifiesOnlyLocally) {
             final ILsaNode n = getLsaNode();
-            if (Objects.requireNonNull(nodePosCache).equals(environment.getPosition(getNode()))) {
+            if (Objects.requireNonNull(nodePosCache).equals(environment.getCurrentPosition(getNode()))) {
                 final List<? extends ILsaMolecule> contents = n.getLsaSpace();
                 if (contents.size() == Objects.requireNonNull(localContentCache).size()) {
                     emptyExecution = localContentCache.containsAll(contents);
diff --git a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/ScafiIncarnationForAlchemist.scala b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/ScafiIncarnationForAlchemist.scala
index 2fd49719b3..05c08c898c 100644
--- a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/ScafiIncarnationForAlchemist.scala
+++ b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/ScafiIncarnationForAlchemist.scala
@@ -81,7 +81,7 @@ object ScafiIncarnationForAlchemist
       val layer: Layer[Any, Position[_]] = alchemistEnvironment.getLayer(new SimpleMolecule(name))
       val node = alchemistEnvironment.getNodeByID(mid())
       layer
-        .getValue(alchemistEnvironment.getPosition(node))
+        .getValue(alchemistEnvironment.getCurrentPosition(node))
         .asInstanceOf[A]
     }
 
diff --git a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/RunScafiProgram.scala b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/RunScafiProgram.scala
index 986713d45a..86c6802dbc 100644
--- a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/RunScafiProgram.scala
+++ b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/RunScafiProgram.scala
@@ -99,7 +99,7 @@ sealed class RunScafiProgram[T, P <: Position[P]](
       case 2 => Point3D(point.getCoordinate(0), point.getCoordinate(1), 0)
       case 3 => Point3D(point.getCoordinate(0), point.getCoordinate(1), point.getCoordinate(2))
     }
-    val position: P = environment.getPosition(node)
+    val position: P = environment.getCurrentPosition(node)
     // NB: We assume it.unibo.alchemist.model.Time = DoubleTime
     //     and that its "time unit" is seconds, and then we get NANOSECONDS
     val alchemistCurrentTime = Try(environment.getSimulation)
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkCentroid.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkCentroid.kt
index ca81e0fe9f..71364b8389 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkCentroid.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkCentroid.kt
@@ -36,7 +36,7 @@ class NetworkCentroid : Extractor<Double> {
     private fun <T> Environment<T, *>.networkHub(): List<Double> {
         val sums = DoubleArray(dimensions) { ORIGIN }
         forEach { node ->
-            getPosition(node).coordinates.forEachIndexed { index, value ->
+            getCurrentPosition(node).coordinates.forEachIndexed { index, value ->
                 sums[index] += value
             }
         }
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkDensity.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkDensity.kt
index 19ad8a5ab3..5cee2fd95a 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkDensity.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NetworkDensity.kt
@@ -35,7 +35,7 @@ class NetworkDensity : Extractor<Double> {
         )
 
         val boundingBox = this.fold(BoundingBox()) { bb, node ->
-            val (x, y) = getPosition(node).coordinates
+            val (x, y) = getCurrentPosition(node).coordinates
             BoundingBox(
                 min(x, bb.minX),
                 max(x, bb.maxX),
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodesPositions.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodesPositions.kt
index 4811b1089d..23b7a804b6 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodesPositions.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/extractors/NodesPositions.kt
@@ -43,7 +43,7 @@ class NodesPositions<T, P : Position<P>>(private val environment: Environment<T,
         return environment.nodes
             .flatMap {
                 val nodeId = it.id
-                val nodePosition = environment.getPosition(it)
+                val nodePosition = environment.getCurrentPosition(it)
                 nodePosition.coordinates.mapIndexed { index, coordinate ->
                     columnNameFormat(nodeId, Dimension(index)) to coordinate
                 }
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/model/deployments/CloseToAlreadyDeployed.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/model/deployments/CloseToAlreadyDeployed.kt
index 2ee71abe18..aa52bcf75f 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/model/deployments/CloseToAlreadyDeployed.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/model/deployments/CloseToAlreadyDeployed.kt
@@ -28,7 +28,7 @@ class CloseToAlreadyDeployed<T, P : Position<P>>(
     override val sources =
         environment.nodes
             .asSequence()
-            .map { environment.getPosition(it) }
+            .map { environment.getCurrentPosition(it) }
             .map {
                 when (it) {
                     is GeoPosition -> doubleArrayOf(it.latitude, it.longitude)
diff --git a/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestLoadGPSTrace.java b/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestLoadGPSTrace.java
index ce71a4ed7c..b8c9369cf4 100755
--- a/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestLoadGPSTrace.java
+++ b/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestLoadGPSTrace.java
@@ -94,7 +94,7 @@ public void finished(
                 for (final Node<T> node : environment.getNodes()) {
                     final GeoPosition start = Objects.requireNonNull(NODE_START_POSITION.get(node));
                     final GeoPosition idealArrive = Objects.requireNonNull(START_ARRIVE_POSITION.get(start));
-                    final GeoPosition realArrive = Objects.requireNonNull(environment.getPosition(node));
+                    final GeoPosition realArrive = Objects.requireNonNull(environment.getCurrentPosition(node));
                     assertEquals(
                             0.0,
                             idealArrive.distanceTo(realArrive),
@@ -108,7 +108,7 @@ public void finished(
             @Override
             public void initialized(@Nonnull final Environment<T, GeoPosition> environment) {
                 for (final Node<T> node : environment.getNodes()) {
-                    final GeoPosition position = environment.getPosition(node);
+                    final GeoPosition position = environment.getCurrentPosition(node);
                     /*
                      * We don't know the actual type of position, we use LatLongPosition here, so we need to make sure
                      * that types match, or the map won't return what we expect
diff --git a/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestYAMLLoader.java b/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestYAMLLoader.java
index 2239b2a69a..3fea73a068 100644
--- a/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestYAMLLoader.java
+++ b/alchemist-loading/src/test/java/it/unibo/alchemist/model/TestYAMLLoader.java
@@ -147,7 +147,7 @@ void testVariableContentClash() {
     void testScalaVar() {
         final Environment<Object, ?> environment = testNoVar("synthetic/scalavar.yml").getEnvironment();
         assertNotNull(environment);
-        assertEquals(environment.makePosition(3, 10), environment.getPosition(environment.getNodeByID(0)));
+        assertEquals(environment.makePosition(3, 10), environment.getCurrentPosition(environment.getNodeByID(0)));
     }
 
     /**
diff --git a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStreamReproducibility.kt b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStreamReproducibility.kt
index f7df0acd20..1a980e643e 100644
--- a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStreamReproducibility.kt
+++ b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestGraphStreamReproducibility.kt
@@ -58,7 +58,7 @@ class TestGraphStreamReproducibility :
                             )
                         }
                         environment.nodes.map { node ->
-                            environment.getPosition(node).coordinates.toList() to
+                            environment.getCurrentPosition(node).coordinates.toList() to
                                 environment.getNeighborhood(node).current.neighbors.map { it.id }
                         }
                     }
diff --git a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestSpecificPositions.kt b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestSpecificPositions.kt
index dc78fec1f1..b8352d13c0 100644
--- a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestSpecificPositions.kt
+++ b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestSpecificPositions.kt
@@ -39,7 +39,7 @@ class TestSpecificPositions :
         "Test YAML loading with 2D env" {
             val loader = LoadAlchemist.from(ResourceLoader.getResource("testSpecificPositions.yml"))
             val environment = loader.getWith<Any, Euclidean2DPosition>(emptyMap<String, Double>()).environment
-            environment.nodes.map { environment.getPosition(it) } shouldBe
+            environment.nodes.map { environment.getCurrentPosition(it) } shouldBe
                 listOf(Euclidean2DPosition(1.0, 2.0), Euclidean2DPosition(3.0, 4.0))
         }
     }) {
diff --git a/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/environments/OSMEnvironment.java b/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/environments/OSMEnvironment.java
index e044770e65..a574917304 100644
--- a/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/environments/OSMEnvironment.java
+++ b/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/environments/OSMEnvironment.java
@@ -237,12 +237,12 @@ public Route<GeoPosition> computeRoute(
         final GeoPosition coord,
         final GraphHopperOptions options
     ) {
-        return computeRoute(getPosition(node), coord, options);
+        return computeRoute(retrievePosition(node), coord, options);
     }
 
     @Override
     public Route<GeoPosition> computeRoute(final Node<T> node, final Node<T> node2) {
-        return computeRoute(node, getPosition(node2));
+        return computeRoute(node, retrievePosition(node2));
     }
 
     @Override
diff --git a/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/movestrategies/speed/StraightLineTraceDependantSpeed.java b/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/movestrategies/speed/StraightLineTraceDependantSpeed.java
index e17dbce4ab..5a13ec6030 100644
--- a/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/movestrategies/speed/StraightLineTraceDependantSpeed.java
+++ b/alchemist-maps/src/main/java/it/unibo/alchemist/model/maps/movestrategies/speed/StraightLineTraceDependantSpeed.java
@@ -57,7 +57,7 @@ protected double computeDistance(
         final Node<T> currentNode,
         final GeoPosition targetPosition
     ) {
-        return environment.getPosition(currentNode).distanceTo(targetPosition);
+        return environment.getCurrentPosition(currentNode).distanceTo(targetPosition);
     }
 
     @Override
diff --git a/alchemist-maps/src/main/kotlin/it/unibo/alchemist/model/maps/actions/RandomTargetInPolygonOnMap.kt b/alchemist-maps/src/main/kotlin/it/unibo/alchemist/model/maps/actions/RandomTargetInPolygonOnMap.kt
index 837a5a7e14..406e9dcb55 100644
--- a/alchemist-maps/src/main/kotlin/it/unibo/alchemist/model/maps/actions/RandomTargetInPolygonOnMap.kt
+++ b/alchemist-maps/src/main/kotlin/it/unibo/alchemist/model/maps/actions/RandomTargetInPolygonOnMap.kt
@@ -37,7 +37,7 @@ class RandomTargetInPolygonOnMap<T, O : RoutingServiceOptions<O>, S : RoutingSer
     node,
     { current, final -> PolygonalChain(current, final) },
     ConstantSpeed(reaction, speed),
-    object : ChangeTargetOnCollision<T, GeoPosition>({ environment.getPosition(node) }) {
+    object : ChangeTargetOnCollision<T, GeoPosition>({ environment.getCurrentPosition(node) }) {
         override fun chooseTarget() = positionGenerator
             .stream()
             .findFirst()
diff --git a/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/actions/TestTargetMapWalker.kt b/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/actions/TestTargetMapWalker.kt
index a817abd208..80f7ebc2ae 100644
--- a/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/actions/TestTargetMapWalker.kt
+++ b/alchemist-maps/src/test/kotlin/it/unibo/alchemist/model/maps/actions/TestTargetMapWalker.kt
@@ -49,73 +49,73 @@ internal class TestTargetMapWalker {
 
     @Test
     fun `Node should not move if no position is set`() {
-        val start = environment.getPosition(node)
+        val start = environment.getCurrentPosition(node)
         assertTrue(STARTPOSITION.distanceTo(start) < 10)
         run()
-        assertEquals(start, environment.getPosition(node))
+        assertEquals(start, environment.getCurrentPosition(node))
     }
 
     @Test
     fun `Node should reach the target position when LatLongPosition is set`() {
-        val start = environment.getPosition(node)
+        val start = environment.getCurrentPosition(node)
         assertTrue(STARTPOSITION.distanceTo(start) < 10)
         node.setConcentration(TRACK, LatLongPosition(ENDLAT, ENDLON))
         run()
-        assertEquals(ENDPOSITION, environment.getPosition(node))
+        assertEquals(ENDPOSITION, environment.getCurrentPosition(node))
     }
 
     @Test
     fun `Node should reach the target position when position is set as Iterable of Doubles`() {
-        val start = environment.getPosition(node)
+        val start = environment.getCurrentPosition(node)
         assertTrue(STARTPOSITION.distanceTo(start) < 10)
         node.setConcentration(TRACK, listOf(ENDLAT, ENDLON))
         run()
-        assertEquals(ENDPOSITION, environment.getPosition(node))
+        assertEquals(ENDPOSITION, environment.getCurrentPosition(node))
     }
 
     @Test
     fun `Node should reach the target position when position is set as Iterable of Strings`() {
-        val start = environment.getPosition(node)
+        val start = environment.getCurrentPosition(node)
         assertTrue(STARTPOSITION.distanceTo(start) < 10)
         node.setConcentration(TRACK, listOf(ENDLAT.toString(), ENDLON.toString()))
         run()
-        assertEquals(ENDPOSITION, environment.getPosition(node))
+        assertEquals(ENDPOSITION, environment.getCurrentPosition(node))
     }
 
     @Test
     fun `Node should reach the target position when position is set as a stringified list of numbers`() {
-        val start = environment.getPosition(node)
+        val start = environment.getCurrentPosition(node)
         assertTrue(STARTPOSITION.distanceTo(start) < 10)
         node.setConcentration(TRACK, listOf(ENDLAT, ENDLON).toString())
         run()
-        assertEquals(ENDPOSITION, environment.getPosition(node))
+        assertEquals(ENDPOSITION, environment.getCurrentPosition(node))
     }
 
     @Test
     fun `Node should reach the target position when position is set as a stringified GeoPosition`() {
-        val start = environment.getPosition(node)
+        val start = environment.getCurrentPosition(node)
         assertTrue(STARTPOSITION.distanceTo(start) < 10)
         node.setConcentration(TRACK, ENDPOSITION.toString())
         run()
-        assertEquals(ENDPOSITION, environment.getPosition(node))
+        assertEquals(ENDPOSITION, environment.getCurrentPosition(node))
     }
 
     @Test
     fun `Node should reach the target position when position is set as an angle bracket string`() {
-        val start = environment.getPosition(node)
+        val start = environment.getCurrentPosition(node)
         assertTrue(STARTPOSITION.distanceTo(start) < 10)
         node.setConcentration(TRACK, "<$ENDLAT $ENDLON>")
         run()
-        assertEquals(ENDPOSITION, environment.getPosition(node))
+        assertEquals(ENDPOSITION, environment.getCurrentPosition(node))
     }
 
     @Test
     fun `Node should reach the target position when position is set as a string with embedded coordinates`() {
-        val start = environment.getPosition(node)
+        val start = environment.getCurrentPosition(node)
         assertTrue(STARTPOSITION.distanceTo(start) < 10)
         node.setConcentration(TRACK, "sakldaskld$ENDLAT fmekfjr$ENDLON sdsad32d")
         run()
-        assertEquals(ENDPOSITION, environment.getPosition(node))
+        assertEquals(ENDPOSITION, environment.getCurrentPosition(node))
     }
 
     companion object {
diff --git a/alchemist-physics/src/main/java/it/unibo/alchemist/model/physics/environments/MuseumHall.java b/alchemist-physics/src/main/java/it/unibo/alchemist/model/physics/environments/MuseumHall.java
index 27e053adeb..e9dc8c2138 100644
--- a/alchemist-physics/src/main/java/it/unibo/alchemist/model/physics/environments/MuseumHall.java
+++ b/alchemist-physics/src/main/java/it/unibo/alchemist/model/physics/environments/MuseumHall.java
@@ -155,7 +155,7 @@ private Euclidean2DPosition nextAllowed(final double ox, final double oy, final
 
     @Override
     public void moveNode(@Nonnull final Node<T> node, final Euclidean2DPosition direction) {
-        final Euclidean2DPosition cur = getPosition(node);
+        final Euclidean2DPosition cur = retrievePosition(node);
         final double ox = cur.getCoordinates()[0];
         final double oy = cur.getCoordinates()[1];
         double nx = direction.getCoordinates()[0] + ox;
@@ -176,7 +176,7 @@ public void moveNode(@Nonnull final Node<T> node, final Euclidean2DPosition dire
     public String toString() {
         final StringBuilder builder = new StringBuilder();
         for (final Node<T> n : getNodes()) {
-            builder.append(getPosition(n)).append(' ').append(n).append('\n');
+            builder.append(retrievePosition(n)).append(' ').append(n).append('\n');
         }
         return builder.toString();
     }
diff --git a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/InfluenceSphere2D.kt b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/InfluenceSphere2D.kt
index fb81e8b824..3a709863be 100644
--- a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/InfluenceSphere2D.kt
+++ b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/InfluenceSphere2D.kt
@@ -29,7 +29,7 @@ open class InfluenceSphere2D<T>(
     override fun influentialNodes(): List<Node<T>> = environment
         .getNodesWithin(
             shape.transformed {
-                origin(environment.getPosition(owner))
+                origin(environment.getCurrentPosition(owner))
                 rotate(environment.getHeading(owner))
             },
         ).minusElement(owner)
diff --git a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/actions/HeadTowardTarget.kt b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/actions/HeadTowardTarget.kt
index 9990db1c4b..e549ae8b50 100644
--- a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/actions/HeadTowardTarget.kt
+++ b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/actions/HeadTowardTarget.kt
@@ -51,9 +51,9 @@ constructor(
             val myHeading = environment.getHeading(node)
             if (targetPosition != myHeading) {
                 if (speedRadians >= 2 * Math.PI) {
-                    environment.setHeading(node, targetPosition - environment.getPosition(node))
+                    environment.setHeading(node, targetPosition - environment.getCurrentPosition(node))
                 } else {
-                    val targetAngle = (targetPosition - environment.getPosition(node)).asAngle
+                    val targetAngle = (targetPosition - environment.getCurrentPosition(node)).asAngle
                     val currentAngle = environment.getHeading(node).asAngle
                     val rotation = shortestRotationAngle(currentAngle, targetAngle)
                     val absDistance = abs(rotation)
diff --git a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/environments/AbstractLimitedContinuous2D.kt b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/environments/AbstractLimitedContinuous2D.kt
index 4e1c583caf..0be8ebee03 100644
--- a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/environments/AbstractLimitedContinuous2D.kt
+++ b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/environments/AbstractLimitedContinuous2D.kt
@@ -29,7 +29,7 @@ abstract class AbstractLimitedContinuous2D<T>(incarnation: Incarnation<T, Euclid
     }
 
     override fun moveNodeToPosition(node: Node<T>, newPosition: Euclidean2DPosition) {
-        val (curX, curY) = getPosition(node).coordinates
+        val (curX, curY) = getCurrentPosition(node).coordinates
         val (newX, newY) = newPosition.coordinates
         super.moveNodeToPosition(node, next(curX, curY, newX, newY))
     }
diff --git a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/environments/ContinuousPhysics2DEnvironment.kt b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/environments/ContinuousPhysics2DEnvironment.kt
index c26510866f..fca43e7b0a 100644
--- a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/environments/ContinuousPhysics2DEnvironment.kt
+++ b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/environments/ContinuousPhysics2DEnvironment.kt
@@ -66,7 +66,7 @@ open class ContinuousPhysics2DEnvironment<T>(incarnation: Incarnation<T, Euclide
     }
 
     override fun getShape(node: Node<T>): Euclidean2DShape = shapefulNodes[node].transformed {
-        origin(getPosition(node))
+        origin(retrievePosition(node))
         rotate(getHeading(node))
     }
 
@@ -127,7 +127,7 @@ open class ContinuousPhysics2DEnvironment<T>(incarnation: Incarnation<T, Euclide
         desiredPosition: Euclidean2DPosition,
         hitboxRadius: Double,
     ): Euclidean2DPosition {
-        val currentPosition = getPosition(node)
+        val currentPosition = retrievePosition(node)
         val desiredMovement = Segment2DImpl(currentPosition, desiredPosition)
         val nodesOnPath =
             nodesOnPath(node, desiredMovement)
diff --git a/alchemist-physics/src/test/kotlin/it/unibo/alchemist/model/physics/environments/TestEuclideanPhysics2DEnvironment.kt b/alchemist-physics/src/test/kotlin/it/unibo/alchemist/model/physics/environments/TestEuclideanPhysics2DEnvironment.kt
index f74d9f1a7d..e58357d41d 100644
--- a/alchemist-physics/src/test/kotlin/it/unibo/alchemist/model/physics/environments/TestEuclideanPhysics2DEnvironment.kt
+++ b/alchemist-physics/src/test/kotlin/it/unibo/alchemist/model/physics/environments/TestEuclideanPhysics2DEnvironment.kt
@@ -60,8 +60,8 @@ class TestEuclideanPhysics2DEnvironment {
     fun `Cannot move into other nodes`() {
         environment.addNode(node1, Euclidean2DPosition(0.0, 0.0))
         environment.addNode(node2, Euclidean2DPosition(3 * DEFAULT_SHAPE_SIZE, 0.0))
-        environment.moveNodeToPosition(node2, environment.getPosition(node1))
-        val distance = environment.getPosition(node1).distanceTo(environment.getPosition(node2))
+        environment.moveNodeToPosition(node2, environment.getCurrentPosition(node1))
+        val distance = environment.getCurrentPosition(node1).distanceTo(environment.getCurrentPosition(node2))
         distance.shouldBeAbout(getNodeRadius(node1) + getNodeRadius(node2))
     }
 
@@ -87,10 +87,10 @@ class TestEuclideanPhysics2DEnvironment {
         environment.addNode(node1, Euclidean2DPosition(2.0, 2.0))
         environment.addNode(node2, Euclidean2DPosition(6.0, 2.0))
         val target = Euclidean2DPosition(8.0, 2.0)
-        val node2toTarget = environment.getPosition(node2).distanceTo(target)
+        val node2toTarget = environment.getCurrentPosition(node2).distanceTo(target)
         environment.moveNodeToPosition(node1, target)
         environment
-            .getPosition(node1)
+            .getCurrentPosition(node1)
             .distanceTo(target)
             .shouldBeAbout(node2toTarget + getNodeRadius(node1) + getNodeRadius(node2))
     }
@@ -102,7 +102,7 @@ class TestEuclideanPhysics2DEnvironment {
         environment.addNode(node3, Euclidean2DPosition(8.0, 2.5))
         val target = Euclidean2DPosition(8.0, 2.0)
         environment.moveNodeToPosition(node1, target)
-        assertTrue(environment.getPosition(node1).distanceTo(target) > getNodeRadius(node1))
+        assertTrue(environment.getCurrentPosition(node1).distanceTo(target) > getNodeRadius(node1))
     }
 
     companion object {
diff --git a/alchemist-smartcam/src/main/kotlin/it/unibo/alchemist/model/actions/CameraInjectVisibleNodeClosestToDistance.kt b/alchemist-smartcam/src/main/kotlin/it/unibo/alchemist/model/actions/CameraInjectVisibleNodeClosestToDistance.kt
index 1f408bae5f..93b93a7610 100644
--- a/alchemist-smartcam/src/main/kotlin/it/unibo/alchemist/model/actions/CameraInjectVisibleNodeClosestToDistance.kt
+++ b/alchemist-smartcam/src/main/kotlin/it/unibo/alchemist/model/actions/CameraInjectVisibleNodeClosestToDistance.kt
@@ -51,7 +51,7 @@ class CameraInjectVisibleNodeClosestToDistance(
                 }
                 @Suppress("UNCHECKED_CAST")
                 val nodes = visibleNodes as List<VisibleNode<*, Euclidean2DPosition>>
-                val myPosition = environment.getPosition(node).surroundingPointAt(
+                val myPosition = environment.getCurrentPosition(node).surroundingPointAt(
                     versor = environment.getHeading(node),
                     distance = distance,
                 )
diff --git a/alchemist-smartcam/src/main/kotlin/it/unibo/alchemist/model/actions/CameraSee.kt b/alchemist-smartcam/src/main/kotlin/it/unibo/alchemist/model/actions/CameraSee.kt
index 780af8351f..518509b0fc 100644
--- a/alchemist-smartcam/src/main/kotlin/it/unibo/alchemist/model/actions/CameraSee.kt
+++ b/alchemist-smartcam/src/main/kotlin/it/unibo/alchemist/model/actions/CameraSee.kt
@@ -61,7 +61,7 @@ constructor(
         filterByMolecule?.run {
             seen = seen.filter { it.contains(filterByMolecule) }
         }
-        node.setConcentration(outputMolecule, seen.map { VisibleNodeImpl(it, environment.getPosition(it)) })
+        node.setConcentration(outputMolecule, seen.map { VisibleNodeImpl(it, environment.getCurrentPosition(it)) })
     }
 
     override fun getContext() = Context.LOCAL
diff --git a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/api/Effect.java b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/api/Effect.java
index 928de97d9a..bdb7ad3ac9 100644
--- a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/api/Effect.java
+++ b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/api/Effect.java
@@ -59,7 +59,7 @@ default <T, P extends Position2D<P>> void apply(
             final Environment<T, P> environment,
             final Wormhole2D<P> wormhole
     ) {
-        final Point viewPoint = wormhole.getViewPoint(environment.getPosition(n));
+        final Point viewPoint = wormhole.getViewPoint(environment.getCurrentPosition(n));
         apply(g, n, viewPoint.x, viewPoint.y); // preserve backward compatibility
     }
 
diff --git a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/AbstractDrawOnce.java b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/AbstractDrawOnce.java
index 06473772d4..2a6e1d625f 100644
--- a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/AbstractDrawOnce.java
+++ b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/AbstractDrawOnce.java
@@ -58,7 +58,7 @@ public <T, P extends Position2D<P>> void apply(
              * if marker node is no longer in the environment or it is no longer displayed, we need to change it
              */
             if (markerNode.isEmpty()
-                    || !wormhole.isInsideView(wormhole.getViewPoint(environment.getPosition(markerNode.get())))) {
+                    || !wormhole.isInsideView(wormhole.getViewPoint(environment.getCurrentPosition(markerNode.get())))) {
                 markerNodeID = null;
             }
         }
diff --git a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/DrawPedestrianPath.java b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/DrawPedestrianPath.java
index 9903516e2b..6e19a98c08 100644
--- a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/DrawPedestrianPath.java
+++ b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/DrawPedestrianPath.java
@@ -79,7 +79,7 @@ protected <T, P extends Position2D<P>> void draw(
             final Environment<T, P> environment,
             final Wormhole2D<P> wormhole
     ) {
-        path.add(environment.getPosition(node));
+        path.add(environment.getCurrentPosition(node));
         if (toBeDrawn) {
             colorCache = new Color(red.getVal(), green.getVal(), blue.getVal(), alpha.getVal());
             graphics2D.setColor(colorCache);
diff --git a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/DrawSmartcam.java b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/DrawSmartcam.java
index 6d21d2116f..4aa0f8085e 100644
--- a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/DrawSmartcam.java
+++ b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/effect/impl/DrawSmartcam.java
@@ -48,7 +48,7 @@ public <T, P extends Position2D<P>> void apply(
             final Wormhole2D<P> wormhole
     ) {
         final double zoom = wormhole.getZoom();
-        final Point viewPoint = wormhole.getViewPoint(environment.getPosition(node));
+        final Point viewPoint = wormhole.getViewPoint(environment.getCurrentPosition(node));
         final int x = viewPoint.x;
         final int y = viewPoint.y;
         if (environment instanceof Physics2DEnvironment) {
diff --git a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/monitor/impl/Generic2DDisplay.java b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/monitor/impl/Generic2DDisplay.java
index f29cdcaef5..2d1d6ccf6e 100644
--- a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/monitor/impl/Generic2DDisplay.java
+++ b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/swingui/monitor/impl/Generic2DDisplay.java
@@ -716,7 +716,7 @@ private void update(final Environment<T, P> environment, final Time time) {
             positions.clear();
             neighbors.clear();
             environment.getNodes().parallelStream().forEach(node -> {
-                positions.put(node, environment.getPosition(node));
+                positions.put(node, environment.getCurrentPosition(node));
                 neighbors.put(node, environment.getNeighborhood(node).getCurrent());
             });
             releaseData();
@@ -891,7 +891,7 @@ public void mouseReleased(final MouseEvent e) {
                             final P envEnding = wormhole.getEnvPoint(endingPoint);
                             final P envOrigin = wormhole.getEnvPoint(originPoint);
                             for (final Node<T> n : selectedNodes) {
-                                final P p = currentEnv.getPosition(n);
+                                final P p = currentEnv.getCurrentPosition(n);
                                 final P finalPos = p.plus(envEnding.minus(envOrigin.getCoordinates()).getCoordinates());
                                 engine.schedule(() -> {
                                     currentEnv.moveNodeToPosition(n, finalPos);
diff --git a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/wormhole/impl/MapWormhole.java b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/wormhole/impl/MapWormhole.java
index a76e636d17..f38a5e1603 100644
--- a/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/wormhole/impl/MapWormhole.java
+++ b/alchemist-swingui/src/main/java/it/unibo/alchemist/boundary/wormhole/impl/MapWormhole.java
@@ -140,7 +140,7 @@ public void optimalZoom() {
             setZoom(zoom);
             zoom--;
         } while (zoom > 1 && !environment.getNodes().parallelStream()
-                .map(environment::getPosition)
+                .map(environment::getCurrentPosition)
                 .map(this::getViewPoint)
                 .allMatch(this::isInsideView));
     }
diff --git a/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/effect/impl/DrawDirectedNode.kt b/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/effect/impl/DrawDirectedNode.kt
index 8f88398196..60fdc4ecc7 100644
--- a/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/effect/impl/DrawDirectedNode.kt
+++ b/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/effect/impl/DrawDirectedNode.kt
@@ -73,7 +73,7 @@ class DrawDirectedNode : it.unibo.alchemist.boundary.swingui.effect.api.Effect {
         environment: Environment<T, P>,
         wormhole: Wormhole2D<P>,
     ) {
-        val nodePosition: P = environment.getPosition(node)
+        val nodePosition: P = environment.getCurrentPosition(node)
         val viewPoint: Point = wormhole.getViewPoint(nodePosition)
         val (x, y) = Pair(viewPoint.x, viewPoint.y)
         drawDirectedNode(g, node, x, y, environment, wormhole)
@@ -156,7 +156,7 @@ class DrawDirectedNode : it.unibo.alchemist.boundary.swingui.effect.api.Effect {
         if (roundedTime >= lastDraw) {
             lastDrawMemory = lastDrawMemory + (node.id to lastDraw + timespan.`val`)
             val updatedPositions =
-                (positions + (environment.getPosition(node) to rotation(node)))
+                (positions + (environment.getCurrentPosition(node) to rotation(node)))
                     .takeLast(MAX_SNAPSHOT_LENGTH)
             positionsMemory = positionsMemory +
                 (node.id to updatedPositions)
diff --git a/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/monitor/impl/NodeTracker.kt b/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/monitor/impl/NodeTracker.kt
index 4f7d374584..2d79dc0abf 100644
--- a/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/monitor/impl/NodeTracker.kt
+++ b/alchemist-swingui/src/main/kotlin/it/unibo/alchemist/boundary/swingui/monitor/impl/NodeTracker.kt
@@ -66,7 +66,7 @@ class NodeTracker<T, P : Position<out P>>(private val node: Node<T>) :
             val content =
                 """
                 |$POSITION
-                |${environment.getPosition(node)}
+                |${environment.getCurrentPosition(node)}
                 |
                 |$CONTENT
                 |${node.contents.map { (k, v) -> "${k.name} -> $v" }.sorted().joinToString(System.lineSeparator())}
diff --git a/alchemist-web-renderer/src/jvmMain/kotlin/it/unibo/alchemist/boundary/webui/server/surrogates/utility/ToNodeSurrogate.kt b/alchemist-web-renderer/src/jvmMain/kotlin/it/unibo/alchemist/boundary/webui/server/surrogates/utility/ToNodeSurrogate.kt
index 503e0f2d75..07d24afd58 100644
--- a/alchemist-web-renderer/src/jvmMain/kotlin/it/unibo/alchemist/boundary/webui/server/surrogates/utility/ToNodeSurrogate.kt
+++ b/alchemist-web-renderer/src/jvmMain/kotlin/it/unibo/alchemist/boundary/webui/server/surrogates/utility/ToNodeSurrogate.kt
@@ -36,5 +36,5 @@ fun <T, P, TS, PS> Node<T>.toNodeSurrogate(
     where TS : Any, P : Position<out P>, PS : PositionSurrogate = NodeSurrogate(
     id,
     contents.map { it.key.toMoleculeSurrogate() to toConcentrationSurrogate(it.value) }.toMap(),
-    toPositionSurrogate(environment.getPosition(this)),
+    toPositionSurrogate(environment.getCurrentPosition(this)),
 )
diff --git a/alchemist-web-renderer/src/jvmTest/kotlin/it/unibo/alchemist/boundary/server/utility/ToNodeSurrogateTest.kt b/alchemist-web-renderer/src/jvmTest/kotlin/it/unibo/alchemist/boundary/server/utility/ToNodeSurrogateTest.kt
index a3b4b0d6d1..d291ba3c82 100644
--- a/alchemist-web-renderer/src/jvmTest/kotlin/it/unibo/alchemist/boundary/server/utility/ToNodeSurrogateTest.kt
+++ b/alchemist-web-renderer/src/jvmTest/kotlin/it/unibo/alchemist/boundary/server/utility/ToNodeSurrogateTest.kt
@@ -55,5 +55,5 @@ fun <T, P, TS, PS> checkToNodeSurrogate(
         nodeSurrogate.contents[surrogateContentKey] shouldBe EmptyConcentrationSurrogate
     }
     node.contents.size shouldBe nodeSurrogate.contents.size
-    checkToPositionSurrogate(environment.getPosition(node), nodeSurrogate.position)
+    checkToPositionSurrogate(environment.getCurrentPosition(node), nodeSurrogate.position)
 }

From a65d0ebc3acde958aad916061c238c1de56578f7 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 22 Jan 2026 12:17:02 +0100
Subject: [PATCH 10/29] chore(api): add way to register to observables without
 sending initial callback

Now the "laziness" concept is applied to dervied observables too.
---
 .../model/observation/DerivedObservable.kt    |  24 ++-
 .../alchemist/model/observation/Observable.kt |  12 +-
 .../model/observation/ObservableExtensions.kt |  64 ++++--
 .../model/observation/LazinessTest.kt         | 189 ++++++++++++++++++
 4 files changed, 263 insertions(+), 26 deletions(-)
 create mode 100644 alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LazinessTest.kt

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
index 0fb63697bd..f75f52a994 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/DerivedObservable.kt
@@ -26,7 +26,7 @@ import java.util.Collections
 abstract class DerivedObservable<T>(private val emitOnDistinct: Boolean = true) : Observable<T> {
     private val callbacks = LinkedHashMap<Any, List<(T) -> Unit>>()
 
-    private var cached: Option<T> = none()
+    protected var cached: Option<T> = none()
 
     private var isListening = false
 
@@ -51,14 +51,15 @@ abstract class DerivedObservable<T>(private val emitOnDistinct: Boolean = true)
         val wasEmpty = callbacks.isEmpty()
         callbacks[registrant] = callbacks[registrant].orEmpty() + callback
         if (wasEmpty) {
-            val initial = computeFresh()
-            cached = initial.some()
+            isListening = true
             if (invokeOnRegistration) {
+                val initial = computeFresh()
+                cached = initial.some()
                 callback(initial)
+                startMonitoring(true)
+            } else {
+                startMonitoring(true)
             }
-
-            isListening = true
-            startMonitoring()
         } else if (invokeOnRegistration) {
             callback(current)
         }
@@ -91,6 +92,17 @@ abstract class DerivedObservable<T>(private val emitOnDistinct: Boolean = true)
      */
     protected abstract fun startMonitoring()
 
+    /**
+     * Initiates monitoring for changes or updates in the implementing class.
+     * This method should enable necessary mechanisms to observe and react to changes
+     * based on the specific implementation of the derived class.
+     *
+     * @param lazy whether the monitoring should be started lazily (avoiding immediate callbacks)
+     */
+    protected open fun startMonitoring(lazy: Boolean) {
+        startMonitoring()
+    }
+
     /**
      * Stops monitoring for changes or updates in the implementing class.
      * This method should disable any active observation mechanisms and ensure
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
index aee2bbb3e8..35eff0af11 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Observable.kt
@@ -79,8 +79,10 @@ interface Observable<T> : Disposable {
 
         override fun computeFresh(): S = transform(this@Observable.current)
 
-        override fun startMonitoring() {
-            this@Observable.onChange(this) {
+        override fun startMonitoring() = startMonitoring(false)
+
+        override fun startMonitoring(lazy: Boolean) {
+            this@Observable.onChange(this, !lazy) {
                 updateAndNotify(transform(it))
             }
         }
@@ -105,13 +107,15 @@ interface Observable<T> : Disposable {
 
         override fun computeFresh(): R = merge(this@Observable.current, other.current)
 
-        override fun startMonitoring() {
+        override fun startMonitoring() = startMonitoring(false)
+
+        override fun startMonitoring(lazy: Boolean) {
             val handleUpdate: (Any?) -> Unit = {
                 updateAndNotify(merge(this@Observable.current, other.current))
             }
 
             listOf(this@Observable, other).forEach { obs ->
-                obs.onChange(this, handleUpdate)
+                obs.onChange(this, !lazy, handleUpdate)
             }
         }
 
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt
index 17c133c262..6494fcf9d9 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableExtensions.kt
@@ -199,8 +199,10 @@ object ObservableExtensions {
 
         override fun computeFresh(): O = aggregator(this@combineLatestCollection.current.map { map(it).current })
 
+        override fun startMonitoring() = startMonitoring(false)
+
         @Suppress("UNCHECKED_CAST")
-        override fun startMonitoring() {
+        override fun startMonitoring(lazy: Boolean) {
             val callback: (C) -> Unit = { current ->
                 reconcile(
                     sources = sources,
@@ -211,8 +213,16 @@ object ObservableExtensions {
                 )
             }
 
-            this@combineLatestCollection.onChange(this, callback)
-            callback(ArrayList(this@combineLatestCollection.current) as C)
+            this@combineLatestCollection.onChange(this, !lazy, callback)
+            if (lazy) {
+                reconcile(
+                    sources = sources,
+                    current = ArrayList(this@combineLatestCollection.current) as C,
+                    map = map,
+                    doOnChange = { updateAndNotify(computeFresh()) },
+                    invokeOnRegistration = cached.getOrNull() != null,
+                )
+            }
         }
 
         override fun stopMonitoring() {
@@ -232,8 +242,10 @@ object ObservableExtensions {
             ?.some()
             ?: none()
 
+        override fun startMonitoring() = startMonitoring(false)
+
         @Suppress("UNCHECKED_CAST")
-        override fun startMonitoring() {
+        override fun startMonitoring(lazy: Boolean) {
             val callback: (C) -> Unit = { current ->
                 reconcile(
                     sources = sources,
@@ -248,8 +260,16 @@ object ObservableExtensions {
                 )
             }
 
-            this@flatMapCollection.onChange(this, callback)
-            callback(ArrayList(this@flatMapCollection.current) as C)
+            this@flatMapCollection.onChange(this, !lazy, callback)
+            if (lazy) {
+                reconcile(
+                    sources = sources,
+                    current = ArrayList(this@flatMapCollection.current) as C,
+                    map = map,
+                    doOnChange = { updateAndNotify(it.some()) },
+                    invokeOnRegistration = cached.getOrNull() != null,
+                )
+            }
         }
 
         override fun stopMonitoring() {
@@ -264,14 +284,15 @@ object ObservableExtensions {
         current: Collection<T>,
         map: (T) -> Observable<O>,
         doOnChange: (O) -> Unit,
-        postCleanup: () -> Unit,
+        postCleanup: () -> Unit = {},
+        invokeOnRegistration: Boolean = true,
     ) {
         val currentSet = current.toSet()
         (sources.keys - currentSet).forEach { sources.remove(it)?.stopWatching(this) }
         (currentSet - sources.keys).forEach { key ->
             with(map(key)) {
                 sources[key] = this
-                onChange(this@reconcile, doOnChange)
+                onChange(this@reconcile, invokeOnRegistration, doOnChange)
             }
         }
         postCleanup()
@@ -296,9 +317,11 @@ object ObservableExtensions {
                 ?.let { _ -> collector(this@combineLatest.map { it.current }).some() }
                 ?: arrow.core.none()
 
-            override fun startMonitoring() {
+            override fun startMonitoring() = startMonitoring(false)
+
+            override fun startMonitoring(lazy: Boolean) {
                 this@combineLatest.forEach { observable ->
-                    observable.onChange(this) { updateAndNotify(computeFresh()) }
+                    observable.onChange(this, !lazy) { updateAndNotify(computeFresh()) }
                 }
             }
 
@@ -320,9 +343,14 @@ object ObservableExtensions {
 
             override fun computeFresh(): R = transform(this@switchMap.current).current
 
-            override fun startMonitoring() {
-                this@switchMap.onChange(this, ::switchInner)
-                switchInner(this@switchMap.current)
+            override fun startMonitoring() = startMonitoring(false)
+
+            override fun startMonitoring(lazy: Boolean) {
+                this@switchMap.onChange(this, !lazy, ::switchInner)
+                if (lazy) {
+                    // a manual switch to set up inner subscription without emitting is required if lazy
+                    switchInner(this@switchMap.current, invokeOnRegistration = cached.getOrNull() != null)
+                }
             }
 
             override fun stopMonitoring() {
@@ -331,12 +359,16 @@ object ObservableExtensions {
                 innerSubscription = null
             }
 
-            private fun switchInner(value: T) {
+            private fun switchInner(value: T) = switchInner(value, true)
+
+            private fun switchInner(value: T, invokeOnRegistration: Boolean) {
                 innerSubscription?.stopWatching(this)
                 with(transform(value)) {
                     innerSubscription = this
-                    onChange(this@switchMap, ::updateAndNotify)
-                    updateAndNotify(this.current)
+                    onChange(this@switchMap, invokeOnRegistration, ::updateAndNotify)
+                    if (invokeOnRegistration) {
+                        updateAndNotify(this.current)
+                    }
                 }
             }
         }
diff --git a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LazinessTest.kt b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LazinessTest.kt
new file mode 100644
index 0000000000..c37750c730
--- /dev/null
+++ b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LazinessTest.kt
@@ -0,0 +1,189 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
+import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.combineLatest
+import it.unibo.alchemist.model.observation.ObservableExtensions.combineLatest
+import it.unibo.alchemist.model.observation.ObservableExtensions.switchMap
+
+class LazinessTest : FunSpec({
+
+    context("DerivedObservable laziness") {
+
+        test("should not compute fresh value if registered lazily") {
+            var computations = 0
+            val derived = object : DerivedObservable<Int>() {
+                override fun computeFresh(): Int {
+                    computations++
+                    return 26
+                }
+
+                override fun startMonitoring() = Unit
+                override fun stopMonitoring() = Unit
+            }
+            derived.onChange(this, false) { }
+            computations shouldBe 0
+        }
+
+        test("should compute fresh value if registered eagerly") {
+            var computations = 0
+            val derived = object : DerivedObservable<Int>() {
+                override fun computeFresh(): Int {
+                    computations++
+                    return 26
+                }
+
+                override fun startMonitoring() = Unit
+                override fun stopMonitoring() = Unit
+            }
+
+            derived.onChange(this, true) { }
+            computations shouldBe 1
+        }
+    }
+
+    context("Map laziness") {
+        test("map should not apply transform if registered lazily") {
+            val source = observe(1)
+            var transforms = 0
+            val mapped = source.map {
+                transforms++
+                it * 2
+            }
+
+            mapped.onChange(this, false) { }
+            transforms shouldBe 0
+        }
+
+        test("map should apply transform if registered eagerly") {
+            val source = observe(1)
+            var transforms = 0
+            val mapped = source.map {
+                transforms++
+                it * 2
+            }
+
+            mapped.onChange(this, true) { }
+            transforms shouldBe 1
+        }
+
+        test("map should receive updates even if registered lazily") {
+            val source = observe(1)
+            val mapped = source.map { it * 2 }
+            var lastSeen: Int? = null
+
+            mapped.onChange(this, false) { lastSeen = it }
+            source.update { 2 }
+            lastSeen shouldBe 4
+        }
+    }
+
+    context("Merge laziness") {
+        test("mergeWith should not merge if registered lazily") {
+            val a = observe(1)
+            val b = observe(2)
+            var merges = 0
+            val merged = a.mergeWith(b) { x, y ->
+                merges++
+                x + y
+            }
+            merged.onChange(this, false) { }
+            merges shouldBe 0
+        }
+
+        test("mergeWith should receive updates from both sources if registered lazily") {
+            val a = observe(1)
+            val b = observe(2)
+            val merged = a.mergeWith(b) { x, y -> x + y }
+            var lastSeen: Int? = null
+
+            merged.onChange(this, false) { lastSeen = it }
+
+            a.update { 3 }
+            lastSeen shouldBe 5
+
+            b.update { 4 }
+            lastSeen shouldBe 7
+        }
+    }
+
+    context("Extension methods laziness") {
+
+        test("combineLatest (collection) should not aggregate if registered lazily") {
+            val set = ObservableMutableSet(1, 2)
+            var aggregations = 0
+            val combined = set.combineLatest(
+                map = { observe(it) },
+                aggregator = {
+                    aggregations++
+                    it.sum()
+                },
+            )
+
+            combined.onChange(this, false) { }
+            aggregations shouldBe 0
+        }
+
+        test("combineLatest (collection) should receive updates if registered lazily") {
+            val set = ObservableMutableSet("a")
+            val inner = observe(10)
+            val combined = set.combineLatest(
+                map = { inner },
+                aggregator = { it.sum() },
+            )
+            var lastSeen: Int? = null
+
+            combined.onChange(this, false) { lastSeen = it }
+
+            inner.update { 20 }
+            lastSeen shouldBe 20
+
+            set.add("b")
+            lastSeen shouldBe 40 // 20 + 20 (both map to same inner)
+        }
+
+        test("combineLatest (list) should not collect if registered lazily") {
+            val list = listOf(observe(1), observe(2))
+            var collections = 0
+            val combined = list.combineLatest {
+                collections++
+                it.sum()
+            }
+
+            combined.onChange(this, false) { }
+            collections shouldBe 0
+        }
+
+        test("switchMap should not transform if registered lazily") {
+            val source = observe(1)
+            var transforms = 0
+            val switched = source.switchMap {
+                transforms++
+                observe(it)
+            }
+            switched.onChange(this, false) { }
+            transforms shouldBe 1
+        }
+
+        test("switchMap should work correctly after lazy registration") {
+            val source = observe(1)
+            val switched = source.switchMap { observe(it * 10) }
+            var lastSeen: Int? = null
+
+            switched.onChange(this, false) { lastSeen = it }
+
+            source.update { 2 }
+            lastSeen shouldBe 20
+        }
+    }
+})

From bce4e43d2b57081c1c8c6e59d8a2dc37e0397174 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 22 Jan 2026 12:27:54 +0100
Subject: [PATCH 11/29] fix(scafi): avoid depending on observables

For actions in general, it is better to use an imperative approach and retrieve the current neighborhood instead of having an up-to-date neighborhood version stored locally.
---
 .../alchemist/model/scafi/actions/SendScafiMessage.scala | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/SendScafiMessage.scala b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/SendScafiMessage.scala
index 9b160cc9b5..06f172ec7d 100644
--- a/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/SendScafiMessage.scala
+++ b/alchemist-incarnation-scafi/src/main/scala/it/unibo/alchemist/model/scafi/actions/SendScafiMessage.scala
@@ -28,13 +28,6 @@ class SendScafiMessage[T, P <: Position[P]](
   assert(reaction != null, "Reaction cannot be null")
   assert(program != null, "Program cannot be null")
 
-  private var neighbors: Iterator[Node[T]] = Iterator.empty
-  environment.getNeighborhood(device.getNode).onChange(this, neighborhood => {
-      neighbors = neighborhood.getNeighbors.iterator().asScala
-      kotlin.Unit.INSTANCE
-    }
-  )
-
   /**
    * This method allows to clone this action on a new node. It may result useful to support runtime creation of nodes
    * with the same reaction programming, e.g. for morphogenesis.
@@ -71,7 +64,7 @@ class SendScafiMessage[T, P <: Position[P]](
   override def execute(): Unit = {
     val toSend = program.getExport(device.getNode.getId).get
     for {
-      neighborhood <- neighbors
+      neighborhood <- environment.getNeighborhood(device.getNode).getCurrent.getNeighbors.iterator().asScala
       action <- ScafiIncarnationUtils.allScafiProgramsFor[T, P](neighborhood).filter(program.getClass.isInstance(_))
       if action.programNameMolecule == program.programNameMolecule
     } action.sendExport(device.getNode.getId, toSend)

From 99774bdd37ad28d290337acf070dea0e356a6d2c Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 22 Jan 2026 16:33:00 +0100
Subject: [PATCH 12/29] feat!: replace Engine with reactive counterpart and get
 rid of dependency graph

fix: remove obsolete reactive engine loading
chore(engine): use explicit synchronisation instead of thread contexts
---
 .../unibo/alchemist/core/DependencyGraph.java |  78 ------
 .../it/unibo/alchemist/core/BatchEngine.kt    |  52 ++--
 .../kotlin/it/unibo/alchemist/core/Engine.kt  | 263 ++----------------
 .../alchemist/core/JGraphTDependencyGraph.kt  | 257 -----------------
 .../it/unibo/alchemist/core/ReactiveEngine.kt | 116 --------
 .../alchemist/core/TestDependencyGraph.kt     |  28 --
 .../alchemist/core/TestEngineComparison.kt    | 146 ----------
 .../core/TestReactiveEngineImplementation.kt  |  12 -
 .../boundary/loader/LoadingSystem.kt          |   8 +-
 .../test/TestReactiveEngineLoading.kt         |  41 ---
 run_all_tests_reactive.sh                     |   2 -
 11 files changed, 53 insertions(+), 950 deletions(-)
 delete mode 100644 alchemist-api/src/main/java/it/unibo/alchemist/core/DependencyGraph.java
 delete mode 100644 alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/JGraphTDependencyGraph.kt
 delete mode 100644 alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/ReactiveEngine.kt
 delete mode 100644 alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestDependencyGraph.kt
 delete mode 100644 alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineComparison.kt
 delete mode 100644 alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveEngineImplementation.kt
 delete mode 100644 alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestReactiveEngineLoading.kt
 delete mode 100755 run_all_tests_reactive.sh

diff --git a/alchemist-api/src/main/java/it/unibo/alchemist/core/DependencyGraph.java b/alchemist-api/src/main/java/it/unibo/alchemist/core/DependencyGraph.java
deleted file mode 100644
index 85292c73e3..0000000000
--- a/alchemist-api/src/main/java/it/unibo/alchemist/core/DependencyGraph.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (C) 2010-2023, Danilo Pianini and contributors
- * listed, for each module, in the respective subproject's build.gradle.kts file.
- *
- * This file is part of Alchemist, and is distributed under the terms of the
- * GNU General Public License, with a linking exception,
- * as described in the file LICENSE in the Alchemist distribution's top directory.
- */
-
-package it.unibo.alchemist.core;
-
-import it.unibo.alchemist.model.Actionable;
-import it.unibo.alchemist.model.Node;
-import org.danilopianini.util.ListSet;
-
-/**
- * This interface allows separating the usage of a dependency graph from its
- * implementation.
- *
- * @param <T>
- *            The parametrization type for reactions
- */
-public interface DependencyGraph<T> {
-
-    /**
-     * Given two nodes, the graph assumes they are now neighbors and calculates the
-     * neighborhood dependencies between them.
-     *
-     * @param n1
-     *            The first node
-     * @param n2
-     *            The second node
-     */
-    void addNeighbor(Node<T> n1, Node<T> n2);
-
-    /**
-     * This method creates the dependencies when a new reaction is added to the
-     * environment. Please be careful when building the environment and populating
-     * the existing reactions map: this method assumes that all the dependencies
-     * among the existing reactions are correct and up to date.
-     *
-     * @param reactionHandler the reaction handler whose dependencies should be calculated.
-     */
-    void createDependencies(Actionable<T> reactionHandler);
-
-    /**
-     * This method removes all the dependencies (both in and out dependencies) for a given reaction handler.
-     * This method is meant to be used to keep the dependencies clean when removing a reaction.
-     *
-     * @param reactionHandler the reaction handler whose dependencies will be deleted.
-     */
-    void removeDependencies(Actionable<T> reactionHandler);
-
-    /**
-     * Given two nodes, the engine assumes they are no longer neighbors and deletes
-     * the neighborhood dependencies between them.
-     *
-     * @param n1
-     *            The first node
-     * @param n2
-     *            The second node
-     */
-    void removeNeighbor(Node<T> n1, Node<T> n2);
-
-    /**
-     * Returns the set of reactions that may be influenced by the provided reaction.
-     *
-     * @param reaction the input reaction
-     * @return the {@link java.util.Set} of reactions that may be influenced by the provided reaction
-     */
-    ListSet<Actionable<T>> outboundDependencies(Actionable<T> reaction);
-
-    /**
-     * @return the {@link java.util.Set} of all reactions
-     *     with a {@link it.unibo.alchemist.model.Context#GLOBAL} input context
-     */
-    ListSet<Actionable<T>> globalInputContextReactions();
-}
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/BatchEngine.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/BatchEngine.kt
index 2d87579848..87abfbf414 100644
--- a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/BatchEngine.kt
+++ b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/BatchEngine.kt
@@ -8,7 +8,6 @@
  */
 package it.unibo.alchemist.core
 
-import com.google.common.collect.Sets
 import it.unibo.alchemist.boundary.OutputMonitor
 import it.unibo.alchemist.core.BatchEngine.OutputReplayStrategy.Aggregate.toReplayStrategy
 import it.unibo.alchemist.model.Actionable
@@ -33,7 +32,6 @@ import org.slf4j.LoggerFactory
 class BatchEngine<T, P : Position<out P>> : Engine<T, P> {
     private val outputReplayStrategy: OutputReplayStrategy
     private val executeLock = Any()
-    private val updateLock = Any()
 
     private constructor(
         environment: Environment<T, P>,
@@ -98,17 +96,17 @@ class BatchEngine<T, P : Position<out P>> : Engine<T, P> {
      */
     override fun doStep() {
         val batchedScheduler = scheduler as BatchedScheduler<T>
-        val nextEvents = batchedScheduler.nextBatch
+        val nextEvents = batchedScheduler.getNextBatch()
         val batchSize = nextEvents.size
         if (nextEvents.isEmpty()) {
-            newStatus(Status.TERMINATED)
+            terminate()
             LOGGER.info("No more reactions.")
             return
         }
-        val sortededNextEvents =
-            nextEvents.stream().sorted(Comparator.comparing(Actionable<T>::tau)).collect(Collectors.toList())
-        val minSlidingWindowTime = sortededNextEvents[0].tau
-        val maxSlidingWindowTime = sortededNextEvents[sortededNextEvents.size - 1].tau
+        val sortedNextEvents = nextEvents.sortedBy { it.tau }
+        val minSlidingWindowTime = sortedNextEvents.first().tau
+        val maxSlidingWindowTime = sortedNextEvents.last().tau
+
         runBlocking {
             val taskMapper =
                 Function { event: Actionable<T> ->
@@ -139,7 +137,7 @@ class BatchEngine<T, P : Position<out P>> : Engine<T, P> {
         is OutputReplayStrategy.Reply ->
             resultsOrderedByTime.forEach(::doStepDoneAllMonitors)
         is OutputReplayStrategy.Aggregate ->
-            doStepDoneAllMonitors(resultsOrderedByTime[resultsOrderedByTime.size - 1])
+            doStepDoneAllMonitors(resultsOrderedByTime.last())
     }
 
     private fun doStepDoneAllMonitors(result: TaskResult) {
@@ -151,19 +149,33 @@ class BatchEngine<T, P : Position<out P>> : Engine<T, P> {
     private fun doEvent(nextEvent: Actionable<T>, slidingWindowTime: Time): TaskResult {
         validateEventExecutionTime(nextEvent, slidingWindowTime)
         val currentLocalTime = nextEvent.tau
+
         if (nextEvent.canExecute()) {
             safeExecuteEvent(nextEvent)
-            safeUpdateEvent(nextEvent)
         }
+
         nextEvent.update(currentLocalTime, true, environment)
-        scheduler.updateReaction(nextEvent)
+        synchronized(scheduler) {
+            scheduler.updateReaction(nextEvent)
+        }
+
         if (environment.isTerminated) {
-            newStatus(Status.TERMINATED)
+            terminate()
             LOGGER.info("Termination condition reached.")
         }
         return TaskResult(nextEvent, currentLocalTime)
     }
 
+    override fun updateReaction(reaction: Actionable<T>) {
+        val previousTau = reaction.tau
+        reaction.update(time, false, environment)
+        if (reaction.tau != previousTau) {
+            synchronized(scheduler) {
+                scheduler.updateReaction(reaction)
+            }
+        }
+    }
+
     private fun validateEventExecutionTime(nextEvent: Actionable<T>, slidingWindowTime: Time) {
         val scheduledTime = nextEvent.tau
         if (!isEventTimeScheduledInFirstBatch(scheduledTime) &&
@@ -198,22 +210,6 @@ class BatchEngine<T, P : Position<out P>> : Engine<T, P> {
         }
     }
 
-    private fun safeUpdateEvent(event: Actionable<T>) {
-        synchronized(updateLock) {
-            var toUpdate: Set<Actionable<T>> = dependencyGraph.outboundDependencies(event)
-            if (!afterExecutionUpdates.isEmpty()) {
-                afterExecutionUpdates.forEach { it.performChanges() }
-                afterExecutionUpdates.clear()
-                toUpdate =
-                    Sets.union(
-                        toUpdate,
-                        dependencyGraph.outboundDependencies(event),
-                    )
-            }
-            toUpdate.forEach { updateReaction(it) }
-        }
-    }
-
     /**
      * Safely set simulation status.
      */
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
index 164d314379..59685369fa 100644
--- a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
+++ b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
@@ -8,18 +8,11 @@
  */
 package it.unibo.alchemist.core
 
-import com.google.common.collect.Sets
 import it.unibo.alchemist.model.Actionable
-import it.unibo.alchemist.model.Context
-import it.unibo.alchemist.model.Dependency
 import it.unibo.alchemist.model.Environment
 import it.unibo.alchemist.model.Neighborhood
 import it.unibo.alchemist.model.Node
 import it.unibo.alchemist.model.Position
-import it.unibo.alchemist.model.Reaction
-import java.util.ArrayDeque
-import java.util.Queue
-import org.jooq.lambda.fi.lang.CheckedRunnable
 
 /**
  * Represents a simulation engine that manages execution and scheduling.
@@ -35,30 +28,16 @@ open class Engine<T, P : Position<out P>>(
     protected val scheduler: Scheduler<T>,
 ) : AbstractEngine<T, P>(environment) {
 
-    /** Queue of updates to be processed after execution. */
-    protected val afterExecutionUpdates: Queue<Update> = ArrayDeque()
-
-    /** Manages dependencies between reactions in the simulation. */
-    protected val dependencyGraph: DependencyGraph<T> = JGraphTDependencyGraph(environment)
-
-    /**
-     * Constructs a simulation with a default scheduler.
-     *
-     * This constructor initializes the simulation with a default [ArrayIndexedPriorityQueue].
-     * If you need a custom [DependencyGraph] or [Scheduler], use the other constructor.
-     *
-     * @param environment the simulation environment
-     */
     constructor(environment: Environment<T, P>) : this(environment, ArrayIndexedPriorityQueue())
 
     override fun initialize() {
-        environment.globalReactions.forEach { reactionAdded(it) }
-        environment.forEach { node -> node.reactions.forEach { scheduleReaction(it) } }
+        environment.globalReactions.forEach(::scheduleReaction)
+        environment.forEach { it.reactions.forEach(::scheduleReaction) }
     }
 
     override fun doStep() {
         val nextEvent = scheduler.getNext() ?: run {
-            newStatus(Status.TERMINATED)
+            terminate()
             LOGGER.info("No more reactions.")
             return
         }
@@ -70,250 +49,64 @@ open class Engine<T, P : Position<out P>>(
         if (scheduledTime.isFinite && nextEvent.canExecute()) {
             nextEvent.conditions.forEach { it.reactionReady() }
             nextEvent.execute()
-            var toUpdate: Set<Actionable<T>> = dependencyGraph.outboundDependencies(nextEvent)
-            if (afterExecutionUpdates.isNotEmpty()) {
-                afterExecutionUpdates.forEach { it.performChanges() }
-                afterExecutionUpdates.clear()
-                toUpdate = Sets.union(toUpdate, dependencyGraph.outboundDependencies(nextEvent))
-            }
-            toUpdate.forEach { updateReaction(it) }
         }
         nextEvent.update(time, true, environment)
         scheduler.updateReaction(nextEvent)
+
         monitors.forEach { it.stepDone(environment, nextEvent, time, step) }
         if (environment.isTerminated) {
-            newStatus(Status.TERMINATED)
+            terminate()
             LOGGER.info("Termination condition reached.")
         }
         currentStep = step + 1
     }
 
-    /**
-     * Registers a newly added neighbor.
-     *
-     * @param node the reference node
-     * @param n the neighbor node
-     */
-    override fun neighborAdded(node: Node<T>, n: Node<T>) {
-        checkCaller()
-        afterExecutionUpdates.add(NeighborAdded(node, n))
-    }
+    /* No dependency graph to update */
+    override fun neighborAdded(node: Node<T>, n: Node<T>) = Unit
 
-    /**
-     * Registers a removed neighbor.
-     *
-     * @param node the reference node
-     * @param n the removed neighbor node
-     */
-    override fun neighborRemoved(node: Node<T>, n: Node<T>) {
-        checkCaller()
-        afterExecutionUpdates.add(NeighborRemoved(node, n))
-    }
+    override fun neighborRemoved(node: Node<T>, n: Node<T>) = Unit
 
-    /**
-     * Handles the addition of a new node.
-     *
-     * @param node the newly added node
-     */
-    override fun nodeAdded(node: Node<T>) {
-        checkCaller()
-        afterExecutionUpdates.add(NodeAddition(node))
-    }
+    override fun nodeMoved(node: Node<T>) = Unit
 
-    /**
-     * Handles node movement.
-     *
-     * @param node the moved node
-     */
-    override fun nodeMoved(node: Node<T>) {
-        checkCaller()
-        afterExecutionUpdates.add(Movement(node))
+    override fun nodeAdded(node: Node<T>) {
+        schedule {
+            node.reactions.forEach { scheduleReaction(it) }
+        }
     }
 
-    /**
-     * Handles the removal of a node.
-     *
-     * @param node the removed node
-     * @param oldNeighborhood the node's neighborhood before removal (used for reverse dependencies)
-     */
     override fun nodeRemoved(node: Node<T>, oldNeighborhood: Neighborhood<T>) {
-        checkCaller()
-        afterExecutionUpdates.add(NodeRemoval(node))
+        schedule {
+            node.reactions.forEach { removeReaction(it) }
+        }
     }
 
-    /**
-     * Registers a newly added reaction.
-     *
-     * @param reactionToAdd the reaction to add
-     */
     override fun reactionAdded(reactionToAdd: Actionable<T>) {
-        reactionChanged(ReactionAddition(reactionToAdd))
+        schedule { scheduleReaction(reactionToAdd) }
     }
 
-    /**
-     * Registers a removed reaction.
-     *
-     * @param reactionToRemove the reaction to remove
-     */
     override fun reactionRemoved(reactionToRemove: Actionable<T>) {
-        reactionChanged(ReactionRemoval(reactionToRemove))
+        schedule { removeReaction(reactionToRemove) }
     }
 
-    /**
-     * Handles reaction changes.
-     *
-     * @param update the update describing the reaction change
-     */
-    private fun reactionChanged(update: AbstractUpdateOnReaction) {
-        checkCaller()
-        afterExecutionUpdates.add(update)
-    }
-
-    /** Retrieves the reactions that require updates after execution. */
-    private fun reactionsToUpdateAfterExecution(): Sequence<Actionable<T>> =
-        afterExecutionUpdates.asSequence().flatMap { it.reactionsToUpdate }.distinct()
-
-    override fun processCommand(command: CheckedRunnable) {
-        command.run()
-        val updated = mutableSetOf<Actionable<T>>()
-        reactionsToUpdateAfterExecution().forEach {
-            updated.add(it)
-            updateReaction(it)
-        }
-        afterExecutionUpdates.forEach { it.performChanges() }
-        afterExecutionUpdates.clear()
-        reactionsToUpdateAfterExecution().forEach { if (it !in updated) updateReaction(it) }
-    }
-
-    /**
-     * Schedules a reaction by setting up dependencies and adding it to the scheduler.
-     *
-     * @param reaction the reaction to schedule
-     */
     private fun scheduleReaction(reaction: Actionable<T>) {
-        dependencyGraph.createDependencies(reaction)
         reaction.initializationComplete(time, environment)
         scheduler.addReaction(reaction)
-    }
-
-    /**
-     * Updates the given reaction, adjusting its scheduling if needed.
-     *
-     * @param r the reaction to update
-     */
-    protected fun updateReaction(r: Actionable<T>) {
-        val previousTau = r.tau
-        r.update(time, false, environment)
-        if (r.tau != previousTau) scheduler.updateReaction(r)
-    }
 
-    /**
-     * Represents a simulation update operation.
-     */
-    protected open inner class Update {
-        /** Performs the update. Override to implement specific behavior. */
-        open fun performChanges() {}
-
-        /** The reactions that require an update. */
-        open val reactionsToUpdate: Sequence<Actionable<T>> = emptySequence()
-    }
-
-    /**
-     * Handles node movement and updates affected reactions.
-     *
-     * @param sourceNode the node that moved
-     */
-    private inner class Movement(private val sourceNode: Node<T>) : Update() {
-        override val reactionsToUpdate: Sequence<Actionable<T>>
-            get() = getReactionsRelatedTo(sourceNode, environment.getNeighborhood(sourceNode).current).filter {
-                it.inboundDependencies.any { dependency -> dependency.dependsOn(Dependency.MOVEMENT) }
-            }
-
-        private fun getReactionsRelatedTo(source: Node<T>, neighborhood: Neighborhood<T>): Sequence<Actionable<T>> =
-            sequenceOf(
-                source.reactions.asSequence(),
-                neighborhood.getNeighbors().asSequence()
-                    .flatMap { it.reactions.asSequence() }
-                    .filter { it.inputContext == Context.NEIGHBORHOOD },
-                dependencyGraph.globalInputContextReactions().asSequence(),
-            ).flatten()
-    }
-
-    /**
-     * Applies an update to all reactions of a node.
-     *
-     * @param sourceNode the node whose reactions should be updated
-     * @param reactionLevelOperation the update operation to apply to each reaction
-     */
-    private open inner class UpdateOnNode(
-        private val sourceNode: Node<T>,
-        private val reactionLevelOperation: (Reaction<T>) -> Update,
-    ) : Update() {
-        override fun performChanges() {
-            sourceNode.reactions.map(reactionLevelOperation).forEach { it.performChanges() }
+        reaction.rescheduleRequest.onChange(this, false) {
+            updateReaction(reaction)
         }
     }
 
-    private inner class NodeRemoval(sourceNode: Node<T>) : UpdateOnNode(sourceNode, { ReactionRemoval(it) })
-
-    private inner class NodeAddition(sourceNode: Node<T>) : UpdateOnNode(sourceNode, { ReactionAddition(it) })
-
-    /**
-     * Represents an update affecting a specific reaction.
-     *
-     * @property sourceReaction the reaction affected by this update
-     */
-    private open inner class AbstractUpdateOnReaction(val sourceReaction: Actionable<T>) : Update() {
-        override val reactionsToUpdate: Sequence<Actionable<T>> = sequenceOf(sourceReaction)
-    }
-
-    /** Handles the removal of a reaction. */
-    private inner class ReactionRemoval(source: Actionable<T>) : AbstractUpdateOnReaction(source) {
-        override fun performChanges() {
-            dependencyGraph.removeDependencies(sourceReaction)
-            scheduler.removeReaction(sourceReaction)
+    protected open fun updateReaction(reaction: Actionable<T>) {
+        val previousTau = reaction.tau
+        reaction.update(time, false, environment)
+        if (reaction.tau != previousTau) {
+            scheduler.updateReaction(reaction)
         }
     }
 
-    /** Handles the addition of a reaction. */
-    private inner class ReactionAddition(source: Actionable<T>) : AbstractUpdateOnReaction(source) {
-        override fun performChanges() {
-            this@Engine.scheduleReaction(sourceReaction)
-        }
-    }
-
-    /**
-     * Handles neighborhood changes, ensuring updates to relevant reactions.
-     *
-     * @property sourceNode the node initiating the change
-     * @property targetNode the node affected by the change
-     */
-    private open inner class NeighborhoodChanged(val sourceNode: Node<T>, val targetNode: Node<T>) : Update() {
-        override val reactionsToUpdate: Sequence<Actionable<T>>
-            get() {
-                val subjects = sequenceOf(sourceNode, targetNode)
-                val sourceNeighbors = environment.getNeighborhood(sourceNode).current.asSequence()
-                val targetNeighbors = environment.getNeighborhood(targetNode).current.asSequence()
-                val allSubjects = (subjects + sourceNeighbors + targetNeighbors).distinct()
-                return allSubjects.flatMap { it.reactions.asSequence() }.filter {
-                    it.inputContext ==
-                        Context.NEIGHBORHOOD
-                } +
-                    dependencyGraph.globalInputContextReactions().asSequence()
-            }
-    }
-
-    /** Handles the addition of a neighbor. */
-    private inner class NeighborAdded(source: Node<T>, target: Node<T>) : NeighborhoodChanged(source, target) {
-        override fun performChanges() {
-            dependencyGraph.addNeighbor(sourceNode, targetNode)
-        }
-    }
-
-    /** Handles the removal of a neighbor. */
-    private inner class NeighborRemoved(source: Node<T>, target: Node<T>) : NeighborhoodChanged(source, target) {
-        override fun performChanges() {
-            dependencyGraph.removeNeighbor(sourceNode, targetNode)
-        }
+    private fun removeReaction(reaction: Actionable<T>) {
+        reaction.rescheduleRequest.stopWatching(this)
+        scheduler.removeReaction(reaction)
     }
 }
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/JGraphTDependencyGraph.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/JGraphTDependencyGraph.kt
deleted file mode 100644
index 8814993771..0000000000
--- a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/JGraphTDependencyGraph.kt
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
- * Copyright (C) 2010-2023, Danilo Pianini and contributors
- * listed, for each module, in the respective subproject's build.gradle.kts file.
- *
- * This file is part of Alchemist, and is distributed under the terms of the
- * GNU General Public License, with a linking exception,
- * as described in the file LICENSE in the Alchemist distribution's top directory.
- */
-package it.unibo.alchemist.core
-
-import it.unibo.alchemist.model.Actionable
-import it.unibo.alchemist.model.Context
-import it.unibo.alchemist.model.Environment
-import it.unibo.alchemist.model.Node
-import it.unibo.alchemist.model.Reaction
-import it.unibo.alchemist.util.BugReporting
-import org.danilopianini.util.ArrayListSet
-import org.danilopianini.util.ListSet
-import org.danilopianini.util.ListSets
-import org.jgrapht.graph.DefaultDirectedGraph
-
-private typealias Edge<T> = Pair<Actionable<T>, Actionable<T>>
-
-/**
- * This class offers an implementation of a dependency graph, namely a
- * data structure which can address in an efficient way the problem of
- * finding those reactions affected by the execution of another
- * reaction. This class relies heavily on the ReactionHandler
- * interface.
- *
- * @param <T> concentration type
- */
-class JGraphTDependencyGraph<T>(private val environment: Environment<T, *>) : DependencyGraph<T> {
-    private val inGlobals = ArrayListSet<Actionable<T>>()
-    private val outGlobals = ArrayListSet<Actionable<T>>()
-    private val graph: DefaultDirectedGraph<Actionable<T>, Edge<T>> = DefaultDirectedGraph(null, null, false)
-    private val runtimeRemovalCache = mutableSetOf<Actionable<T>>()
-
-    override fun createDependencies(newReaction: Actionable<T>) {
-        val allReactions = graph.vertexSet()
-        val neighborhood by lazy {
-            if (newReaction is Reaction) {
-                newReaction.node.neighborhood
-            } else {
-                ListSets.emptyListSet()
-            }
-        }
-        val localReactions by lazy {
-            if (newReaction is Reaction) {
-                newReaction.node.reactions
-                    .filter { allReactions.contains(it) }
-                    .asSequence()
-            } else {
-                emptySequence()
-            }
-        }
-        val neighborhoodReactions by lazy {
-            neighborhood
-                .asSequence()
-                .flatMap { it.reactions.asSequence() }
-                .filter { allReactions.contains(it) }
-                .toList()
-                .asSequence()
-        }
-        val extendedNeighborhoodReactions by lazy {
-            neighborhood
-                .asSequence()
-                // Neighbors of neighbors
-                .flatMap { it.neighborhood.asSequence() }
-                // No duplicates
-                .distinct()
-                // Exclude self and direct neighbors
-                .filterNot { it == newReaction.node || it in neighborhood }
-                .flatMap { it.reactions.asSequence() }
-                .filter { allReactions.contains(it) }
-                .toList()
-                .asSequence()
-        }
-
-        fun Context.candidates(
-            oppositeGlobal: Sequence<Actionable<T>>,
-            oppositeContext: Actionable<T>.() -> Context,
-        ): Sequence<Actionable<T>> = when (this) {
-            Context.LOCAL ->
-                oppositeGlobal +
-                    localReactions +
-                    neighborhoodReactions.filter { it.oppositeContext() == Context.NEIGHBORHOOD }
-            Context.NEIGHBORHOOD ->
-                oppositeGlobal +
-                    localReactions +
-                    neighborhoodReactions +
-                    extendedNeighborhoodReactions.filter { it.oppositeContext() == Context.NEIGHBORHOOD }
-            Context.GLOBAL ->
-                allReactions.asSequence()
-        }
-        val inboundCandidates: Sequence<Actionable<T>> =
-            newReaction.inputContext.candidates(outGlobals.asSequence()) { outputContext }
-        val outboundCandidates: Sequence<Actionable<T>> =
-            newReaction.outputContext.candidates(inGlobals.asSequence()) { inputContext }
-        check(graph.addVertex(newReaction)) {
-            "$newReaction was already in the dependency graph"
-        }
-        inboundCandidates
-            .filter { newReaction.dependsOn(it) }
-            .forEach { graph.addEdge(it, newReaction, Edge(it, newReaction)) }
-        outboundCandidates
-            .filter { it.dependsOn(newReaction) }
-            .forEach { graph.addEdge(newReaction, it, Edge(newReaction, it)) }
-        if (newReaction.inputContext == Context.GLOBAL) {
-            inGlobals.add(newReaction)
-        }
-        if (newReaction.outputContext == Context.GLOBAL) {
-            outGlobals.add(newReaction)
-        }
-    }
-
-    override fun removeDependencies(reaction: Actionable<T>) {
-        fun bugInfo() = mapOf(
-            "reaction" to reaction,
-            "graph" to graph,
-            "incarnation" to environment.incarnation,
-            "environment" to environment,
-        )
-
-        fun bug(message: String): Nothing = BugReporting.reportBug(message, bugInfo())
-        if (!graph.removeVertex(reaction)) {
-            bug("Reaction does not exists in the dependency graph.")
-        }
-        if (reaction.inputContext == Context.GLOBAL && !inGlobals.remove(reaction)) {
-            bug("Inconsistent state: $reaction, with global input context, was not in the appropriate pool.")
-        }
-        if (reaction.outputContext == Context.GLOBAL && !outGlobals.remove(reaction)) {
-            bug("Inconsistent state: $reaction, with global input context, was not in the appropriate pool.")
-        }
-        runtimeRemovalCache += reaction
-    }
-
-    private fun addNeighborDirected(n1: Node<T>, n2: Node<T>) {
-        val n2NonGlobalReactions: Iterable<Reaction<T>> by lazy {
-            n2.reactions.filterNot { it.outputContext == Context.GLOBAL }
-        }
-        val n2NeighborhoodReactions: Iterable<Reaction<T>> by lazy {
-            n2NonGlobalReactions.filter { it.outputContext == Context.NEIGHBORHOOD }
-        }
-        val neighborInputInfluencers: Iterable<Reaction<T>> by lazy {
-            // All the non-global reactions of the new neighbor
-            n2NonGlobalReactions +
-                // Plus all the reactions of the new neighbor's neighbors with neighborhood output
-                (n2.neighborhood - setOf(n1) - n1.neighborhood)
-                    .asSequence()
-                    .flatMap { it.reactions.asSequence() }
-                    .filter { it.outputContext == Context.NEIGHBORHOOD }
-        }
-        n1.reactions.forEach { reaction ->
-            when (reaction.inputContext) {
-                // Local-reading reactions can be only influenced by the new neighbor's neighborhood reactions
-                Context.LOCAL -> n2NeighborhoodReactions
-                Context.NEIGHBORHOOD -> neighborInputInfluencers
-                else -> emptyList()
-            }.asSequence()
-                .filter { reaction.dependsOn(it) }
-                .forEach { graph.addEdge(it, reaction, Edge(it, reaction)) }
-        }
-    }
-
-    /** @see [DependencyGraph.addNeighbor] */
-    override fun addNeighbor(n1: Node<T>, n2: Node<T>) {
-        addNeighborDirected(n1, n2)
-        addNeighborDirected(n2, n1)
-    }
-
-    /**
-     * Remove edges linking reactions in [n1] that could have influenced reactions in [n2].
-     * - reactions of n1 with output local may have influenced those with input neighborhood in [n2]
-     * - reactions of n1 with output neighborhood may have influenced those with input local or neighborhood in [n2]
-     *   plus those with input neighborhood in the n2's neighborhood that is no longer part of [n1] neighborhood
-     * - reactions with global output are unmodified
-     */
-    private fun removeNeighborDirected(n1: Node<T>, n2: Node<T>) {
-        val n2NonGlobalReactions by lazy { n2.reactions.filterNot { it.inputContext == Context.GLOBAL } }
-        val n2NeighborhoodReactions by lazy { n2NonGlobalReactions.filter { it.inputContext == Context.NEIGHBORHOOD } }
-        val neighborOutputInfluencers by lazy {
-            // All the non-global reactions of the old neighbor
-            n2NonGlobalReactions +
-                // Plus all the reactions of the new neighbor's neighbors with neighborhood output
-                (n2.neighborhood - setOf(n1) - n1.neighborhood - n1.neighborhood.flatMap { it.neighborhood }.toSet())
-                    .asSequence()
-                    .flatMap { it.reactions.asSequence() }
-                    .filter { it.inputContext == Context.NEIGHBORHOOD }
-                    .toList()
-        }
-        n1.reactions.forEach { reaction ->
-            when (reaction.outputContext) {
-                // Local-reading reactions may have been influenced only by the ex neighbor neigh-writing reactions
-                Context.LOCAL -> n2NeighborhoodReactions
-                Context.NEIGHBORHOOD -> neighborOutputInfluencers
-                else -> emptyList()
-            }.asSequence()
-                .filter { reaction.dependsOn(it) }
-                .forEach { graph.removeEdge(it, reaction) }
-        }
-    }
-
-    override fun removeNeighbor(n1: Node<T>, n2: Node<T>) {
-        removeNeighborDirected(n1, n2)
-        removeNeighborDirected(n2, n1)
-    }
-
-    override fun outboundDependencies(reaction: Actionable<T>?): ListSet<Actionable<T>> {
-        if (graph.containsVertex(reaction)) {
-            return graph.outgoingEdgesOf(reaction).let { edges ->
-                edges.mapTo(ArrayListSet(edges.size)) { it.second }
-            }
-        }
-        require(runtimeRemovalCache.remove(reaction)) {
-            BugReporting.reportBug(
-                "A reaction that is being updated does not exists in the dependency graph, " +
-                    "nor has been scheduled for removal.",
-                mapOf(
-                    "graph" to graph,
-                    "incarnation" to environment.incarnation,
-                    "environment" to environment,
-                    "reaction" to reaction,
-                ),
-            )
-        }
-        return ListSets.emptyListSet()
-    }
-
-    override fun toString() = graph.toString()
-
-    override fun globalInputContextReactions(): ListSet<Actionable<T>> = ListSets.unmodifiableListSet(inGlobals)
-
-    private val Actionable<T>.node: Node<T> get() = checkNotNull(this as? Reaction).node
-
-    private fun Actionable<T>.dependsOn(other: Actionable<T>) = inboundDependencies.any { inbound ->
-        other.outboundDependencies.any { outbound ->
-            inbound.dependsOn(outbound) || outbound.makesDependent(inbound)
-        }
-    }
-
-    private val Node<T>.neighborhood get() = environment.getNeighborhood(this).current.neighbors
-
-    private companion object {
-        private val Actionable<*>.inputContext get() =
-            when (this) {
-                is Reaction -> inputContext
-                else -> Context.GLOBAL
-            }
-
-        private val Actionable<*>.outputContext get() =
-            when (this) {
-                is Reaction -> outputContext
-                else -> Context.GLOBAL
-            }
-    }
-}
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/ReactiveEngine.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/ReactiveEngine.kt
deleted file mode 100644
index 72e0858d09..0000000000
--- a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/ReactiveEngine.kt
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (C) 2010-2026, Danilo Pianini and contributors
- * listed, for each module, in the respective subproject's build.gradle.kts file.
- *
- * This file is part of Alchemist, and is distributed under the terms of the
- * GNU General Public License, with a linking exception,
- * as described in the file LICENSE in the Alchemist distribution's top directory.
- */
-
-package it.unibo.alchemist.core
-
-import it.unibo.alchemist.model.Actionable
-import it.unibo.alchemist.model.Environment
-import it.unibo.alchemist.model.Neighborhood
-import it.unibo.alchemist.model.Node
-import it.unibo.alchemist.model.Position
-
-/**
- * A reactive implementation of the [Simulation] engine.
- * This engine does not use a dependency graph. Instead, it relies on [Actionable]s
- * (Reactions) being reactive based on what they [observe][it.unibo.alchemist.model.observation.Observable].
- * Sources' (nodes' contents, positions, neighborhoods, ...) changes will automatically trigger reactions
- * updates and reschedules.
- *
- * @param T the concentration type
- * @param P the position type, extending [Position]
- * @property environment the simulation environment
- * @property scheduler the scheduler managing event execution
- */
-open class ReactiveEngine<T, P : Position<out P>>(
-    private val environment: Environment<T, P>,
-    protected val scheduler: Scheduler<T>,
-) : AbstractEngine<T, P>(environment) {
-
-    constructor(environment: Environment<T, P>) : this(environment, ArrayIndexedPriorityQueue())
-
-    override fun initialize() {
-        environment.globalReactions.forEach(::scheduleReaction)
-        environment.forEach { it.reactions.forEach(::scheduleReaction) }
-    }
-
-    override fun doStep() {
-        val nextEvent = scheduler.getNext() ?: run {
-            terminate()
-            LOGGER.info("No more reactions.")
-            return
-        }
-        val scheduledTime = nextEvent.tau
-        check(scheduledTime >= time) {
-            "$nextEvent is scheduled in the past at time $scheduledTime. Current time: $time; current step: $step."
-        }
-        currentTime = scheduledTime
-        if (scheduledTime.isFinite && nextEvent.canExecute()) {
-            nextEvent.conditions.forEach { it.reactionReady() }
-            nextEvent.execute()
-        }
-        nextEvent.update(time, true, environment)
-        scheduler.updateReaction(nextEvent)
-
-        monitors.forEach { it.stepDone(environment, nextEvent, time, step) }
-        if (environment.isTerminated) {
-            terminate()
-            LOGGER.info("Termination condition reached.")
-        }
-        currentStep = step + 1
-    }
-
-    /* No dependency graph to update */
-    override fun neighborAdded(node: Node<T>, n: Node<T>) = Unit
-
-    override fun neighborRemoved(node: Node<T>, n: Node<T>) = Unit
-
-    override fun nodeMoved(node: Node<T>) = Unit
-
-    override fun nodeAdded(node: Node<T>) {
-        schedule {
-            node.reactions.forEach { scheduleReaction(it) }
-        }
-    }
-
-    override fun nodeRemoved(node: Node<T>, oldNeighborhood: Neighborhood<T>) {
-        schedule {
-            node.reactions.forEach { removeReaction(it) }
-        }
-    }
-
-    override fun reactionAdded(reactionToAdd: Actionable<T>) {
-        schedule { scheduleReaction(reactionToAdd) }
-    }
-
-    override fun reactionRemoved(reactionToRemove: Actionable<T>) {
-        schedule { removeReaction(reactionToRemove) }
-    }
-
-    private fun scheduleReaction(reaction: Actionable<T>) {
-        reaction.initializationComplete(time, environment)
-        scheduler.addReaction(reaction)
-
-        reaction.rescheduleRequest.onChange(this) {
-            updateReaction(reaction)
-        }
-    }
-
-    protected fun updateReaction(reaction: Actionable<T>) {
-        val previousTau = reaction.tau
-        reaction.update(time, false, environment)
-        if (reaction.tau != previousTau) {
-            scheduler.updateReaction(reaction)
-        }
-    }
-
-    private fun removeReaction(reaction: Actionable<T>) {
-        reaction.rescheduleRequest.stopWatching(this)
-        scheduler.removeReaction(reaction)
-    }
-}
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestDependencyGraph.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestDependencyGraph.kt
deleted file mode 100644
index 1425bba0a3..0000000000
--- a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestDependencyGraph.kt
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2010-2023, Danilo Pianini and contributors
- * listed, for each module, in the respective subproject's build.gradle.kts file.
- *
- * This file is part of Alchemist, and is distributed under the terms of the
- * GNU General Public License, with a linking exception,
- * as described in the file LICENSE in the Alchemist distribution's top directory.
- */
-
-package it.unibo.alchemist.core
-
-import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
-import it.unibo.alchemist.model.Environment
-import it.unibo.alchemist.model.Reaction
-
-class TestDependencyGraph : AbstractDependencyTest() {
-
-    private lateinit var graph: DependencyGraph<Double>
-
-    override fun beforeTest(environment: Environment<Double, *>) {
-        graph = JGraphTDependencyGraph(environment)
-        environment.nodes.flatMap { it.reactions }.forEach { graph.createDependencies(it) }
-    }
-
-    override fun Reaction<Double>.assertDependencies(vararg dependencies: Reaction<Double>) {
-        graph.outboundDependencies(this).toList() shouldContainExactlyInAnyOrder dependencies.toList()
-    }
-}
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineComparison.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineComparison.kt
deleted file mode 100644
index 7acd1dd7c0..0000000000
--- a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineComparison.kt
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright (C) 2010-2026, Danilo Pianini and contributors
- * listed, for each module, in the respective subproject's build.gradle.kts file.
- *
- * This file is part of Alchemist, and is distributed under the terms of the
- * GNU General Public License, with a linking exception,
- * as described in the file LICENSE in the Alchemist distribution's top directory.
- */
-
-package it.unibo.alchemist.core
-
-import io.kotest.core.spec.style.FreeSpec
-import io.kotest.matchers.collections.shouldContainExactly
-import it.unibo.alchemist.boundary.OutputMonitor
-import it.unibo.alchemist.core.util.DependencyUtils
-import it.unibo.alchemist.model.Actionable
-import it.unibo.alchemist.model.Environment
-import it.unibo.alchemist.model.Molecule
-import it.unibo.alchemist.model.Node
-import it.unibo.alchemist.model.Position
-import it.unibo.alchemist.model.Time
-import it.unibo.alchemist.model.biochemistry.BiochemistryIncarnation
-import it.unibo.alchemist.model.biochemistry.molecules.Biomolecule
-import it.unibo.alchemist.model.conditions.MoleculeHasConcentration
-import it.unibo.alchemist.model.environments.Continuous2DEnvironment
-import it.unibo.alchemist.model.linkingrules.NoLinks
-import it.unibo.alchemist.model.nodes.GenericNode
-import it.unibo.alchemist.model.timedistributions.DiracComb
-import it.unibo.alchemist.model.times.DoubleTime
-import java.util.concurrent.CopyOnWriteArrayList
-import kotlin.jvm.optionals.getOrNull
-import org.junit.jupiter.api.fail
-
-class TestEngineComparison : FreeSpec({
-
-    data class TraceEntry(val time: Double, val nodeId: Int, val molecule: String, val concentration: Double)
-
-    class TraceMonitor<T, P : Position<out P>> : OutputMonitor<T, P> {
-        val trace = CopyOnWriteArrayList<TraceEntry>()
-
-        override fun stepDone(environment: Environment<T, P>, reaction: Actionable<T>?, time: Time, step: Long) {
-            environment.nodes.forEach { node ->
-                node.contents.forEach { (mol, conc) ->
-                    trace.add(TraceEntry(time.toDouble(), node.id, mol.name, (conc as Number).toDouble()))
-                }
-            }
-        }
-    }
-
-    fun prepareEnvironment(): Continuous2DEnvironment<Double> {
-        val incarnation = BiochemistryIncarnation()
-        val environment = Continuous2DEnvironment(incarnation)
-        environment.linkingRule = NoLinks()
-        environment.addTerminator { it.simulation.time > DoubleTime(10.0) }
-        return environment
-    }
-
-    fun runAndTrace(
-        setup: (Continuous2DEnvironment<Double>) -> Unit,
-        engineFactory: (Environment<Double, *>) -> Simulation<Double, *>,
-    ): List<TraceEntry> {
-        val environment = prepareEnvironment()
-        setup(environment)
-        val monitor = TraceMonitor<Double, Position<*>>()
-
-        @Suppress("UNCHECKED_CAST")
-        val engine = engineFactory(environment as Environment<Double, *>) as Simulation<Double, Position<*>>
-        engine.addOutputMonitor(monitor)
-
-        engine.play()
-        engine.run()
-
-        engine.error.getOrNull()?.let { err ->
-            fail { "Simulation failed with an error: ${err.message}: ${err.stackTraceToString()}" }
-        }
-
-        return monitor.trace
-    }
-
-    val a = Biomolecule("A")
-    val b = Biomolecule("B")
-    val c = Biomolecule("C")
-
-    fun setupNode(env: Continuous2DEnvironment<Double>): GenericNode<Double> {
-        val node = GenericNode(env)
-        node.setConcentration(a, 1.0)
-        node.setConcentration(b, 0.0)
-        node.setConcentration(c, 0.0)
-        return node
-    }
-
-    fun addReaction(node: Node<Double>, rate: Double, conditionMolecule: Molecule, action: () -> Unit) {
-        DependencyUtils.SimpleReaction(node, DiracComb(rate)) {
-            action()
-        }.apply {
-            conditions = listOf(MoleculeHasConcentration(node, conditionMolecule, 1.0))
-            node.addReaction(this)
-        }
-    }
-
-    "Compare Engine and ReactiveEngine" - {
-        listOf(
-            "Simple Chain: A -> B -> C" to { env: Continuous2DEnvironment<Double> ->
-                val node = setupNode(env)
-                addReaction(node, 1.0, a) {
-                    node.setConcentration(a, 0.0)
-                    node.setConcentration(b, 1.0)
-                }
-                addReaction(node, 1.0, b) {
-                    node.setConcentration(b, 0.0)
-                    node.setConcentration(c, 1.0)
-                }
-                env.addNode(node, env.makePosition(0, 0))
-                Unit
-            },
-            "Simple Branching: A -> B, A -> C" to { env: Continuous2DEnvironment<Double> ->
-                val node = setupNode(env)
-                addReaction(node, 1.0, a) {
-                    node.setConcentration(b, node.getConcentration(b) + 1.0)
-                }
-                addReaction(node, 0.5, a) {
-                    node.setConcentration(c, node.getConcentration(c) + 1.0)
-                }
-                env.addNode(node, env.makePosition(0, 0))
-                Unit
-            },
-            "Simple Feedback Loop: A -> B -> A" to { env: Continuous2DEnvironment<Double> ->
-                val node = setupNode(env)
-                addReaction(node, 1.0, a) {
-                    node.setConcentration(a, 0.0)
-                    node.setConcentration(b, 1.0)
-                }
-                addReaction(node, 1.0, b) {
-                    node.setConcentration(b, 0.0)
-                    node.setConcentration(a, 1.0)
-                }
-                env.addNode(node, env.makePosition(0, 0))
-                Unit
-            },
-        ).forEach { (_, setup) ->
-            val traceEngine = runAndTrace(setup) { Engine(it) }
-            val traceReactive = runAndTrace(setup) { ReactiveEngine(it) }
-            traceReactive shouldContainExactly traceEngine
-        }
-    }
-})
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveEngineImplementation.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveEngineImplementation.kt
deleted file mode 100644
index 95735ed7a5..0000000000
--- a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestReactiveEngineImplementation.kt
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * Copyright (C) 2010-2026, Danilo Pianini and contributors
- * listed, for each module, in the respective subproject's build.gradle.kts file.
- *
- * This file is part of Alchemist, and is distributed under the terms of the
- * GNU General Public License, with a linking exception,
- * as described in the file LICENSE in the Alchemist distribution's top directory.
- */
-
-package it.unibo.alchemist.core
-
-class TestReactiveEngineImplementation : AbstractEngineTest({ env -> ReactiveEngine(env) })
diff --git a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/loader/LoadingSystem.kt b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/loader/LoadingSystem.kt
index 862fdccba2..4b53e86492 100644
--- a/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/loader/LoadingSystem.kt
+++ b/alchemist-loading/src/main/kotlin/it/unibo/alchemist/boundary/loader/LoadingSystem.kt
@@ -15,7 +15,6 @@ import it.unibo.alchemist.boundary.exporters.GlobalExporter
 import it.unibo.alchemist.boundary.loader.LoadingSystemLogger.logger
 import it.unibo.alchemist.boundary.loader.syntax.AlchemistYamlSyntax
 import it.unibo.alchemist.core.Engine
-import it.unibo.alchemist.core.ReactiveEngine
 import it.unibo.alchemist.core.Simulation
 import it.unibo.alchemist.model.Deployment
 import it.unibo.alchemist.model.Environment
@@ -150,12 +149,7 @@ internal abstract class LoadingSystem(private val originalContext: Context, priv
             val engine: Simulation<T, P> = SimulationModel
                 .visitBuilding<Simulation<T, P>>(context, engineDescriptor)
                 ?.getOrThrow()
-                ?: if (System.getProperty("alchemist.engine", "default") == "reactive") {
-                        logger.warn("Using experimental reactive APIs")
-                        ReactiveEngine(environment)
-                    } else {
-                        Engine(environment)
-                    }
+                ?: Engine(environment)
             // Attach monitors
             monitors.forEach(engine::addOutputMonitor)
             // Attach data exporters
diff --git a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestReactiveEngineLoading.kt b/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestReactiveEngineLoading.kt
deleted file mode 100644
index 5e405d4672..0000000000
--- a/alchemist-loading/src/test/kotlin/it/unibo/alchemist/test/TestReactiveEngineLoading.kt
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2010-2023, Danilo Pianini and contributors
- * listed, for each module, in the respective subproject's build.gradle.kts file.
- *
- * This file is part of Alchemist, and is distributed under the terms of the
- * GNU General Public License, with a linking exception,
- * as described in the file LICENSE in the Alchemist distribution's top directory.
- */
-
-package it.unibo.alchemist.test
-
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.shouldBe
-import io.kotest.matchers.types.shouldBeInstanceOf
-import it.unibo.alchemist.boundary.LoadAlchemist
-import it.unibo.alchemist.core.ReactiveEngine
-import it.unibo.alchemist.model.positions.Euclidean2DPosition
-import org.kaikikm.threadresloader.ResourceLoader
-
-class TestReactiveEngineLoading : StringSpec({
-
-    "It should be possible to load a simulation with the ReactiveEngine via YAML overrides" {
-        val yaml = "synthetic/scalavar.yml"
-        val overrides = listOf(
-            """
-            engine:
-                type: it.unibo.alchemist.core.ReactiveEngine
-            """.trimIndent(),
-        )
-
-        val resource = ResourceLoader.getResource(yaml)
-        val loader = LoadAlchemist.from(resource, overrides)
-        val simulation = loader.getDefault<Any, Euclidean2DPosition>()
-
-        simulation.shouldBeInstanceOf<ReactiveEngine<Any, Euclidean2DPosition>>()
-
-        simulation.play()
-        simulation.run()
-        simulation.error.isPresent shouldBe false
-    }
-})
diff --git a/run_all_tests_reactive.sh b/run_all_tests_reactive.sh
deleted file mode 100755
index 86b2207a9e..0000000000
--- a/run_all_tests_reactive.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash
-./gradlew -Dalchemist.engine=reactive test

From 443eb011fb611b44236a194b6005ff1731f71db3 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 29 Jan 2026 10:54:47 +0100
Subject: [PATCH 13/29] fix: properly implement and call `dispose` on nodes and
 reactions

---
 .../kotlin/it/unibo/alchemist/model/Actionable.kt    |  4 +++-
 .../src/main/kotlin/it/unibo/alchemist/model/Node.kt |  4 +++-
 .../model/environments/AbstractEnvironment.kt        |  2 ++
 .../it/unibo/alchemist/model/nodes/GenericNode.kt    | 12 +++++++++++-
 .../model/sapere/reactions/SAPEREGradient.java       |  7 +++++++
 .../model/physics/reactions/PhysicsUpdate.kt         |  8 ++++++++
 .../it/unibo/alchemist/test/GlobalTestReaction.kt    |  7 +++++++
 7 files changed, 41 insertions(+), 3 deletions(-)

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
index 861b2855e1..b443bbdd62 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
@@ -9,6 +9,7 @@
 
 package it.unibo.alchemist.model
 
+import it.unibo.alchemist.model.observation.Disposable
 import it.unibo.alchemist.model.observation.Observable
 import java.io.Serializable
 import org.danilopianini.util.ListSet
@@ -18,7 +19,8 @@ import org.danilopianini.util.ListSet
  */
 sealed interface Actionable<T> :
     Comparable<Actionable<T>>,
-    Serializable {
+    Serializable,
+    Disposable {
     /**
      * @return true if the reaction can be executed (namely, all the conditions
      * are satisfied).
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
index 646d2b79c8..b1fca9a5d4 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
@@ -9,6 +9,7 @@
 package it.unibo.alchemist.model
 
 import arrow.core.Option
+import it.unibo.alchemist.model.observation.Disposable
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableMap
 import java.io.Serializable
@@ -25,7 +26,8 @@ import kotlin.reflect.jvm.jvmErasure
 interface Node<T> :
     Serializable,
     Iterable<Reaction<T>>,
-    Comparable<Node<T>> {
+    Comparable<Node<T>>,
+    Disposable {
     /**
      * Adds a reaction to this node.
      * The reaction is added only in the node,
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
index 708e51a1fc..036aea8cda 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
@@ -27,6 +27,7 @@ import it.unibo.alchemist.model.Position
 import it.unibo.alchemist.model.SupportedIncarnations
 import it.unibo.alchemist.model.TerminationPredicate
 import it.unibo.alchemist.model.linkingrules.NoLinks
+import it.unibo.alchemist.model.observation.Disposable
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableMutableMap
 import it.unibo.alchemist.model.observation.ObservableMutableSet
@@ -443,6 +444,7 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         updateRegionObservers(node, null, null)
         ifEngineAvailable { it.nodeRemoved(node, neigh) }
         nodeRemoved(node, neigh)
+        node.dispose()
     }
 
     private fun runQuery(center: P, range: Double): List<Node<T>> = spatialIndex
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
index ea6bbddb91..9592fae0a5 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
@@ -17,6 +17,7 @@ import it.unibo.alchemist.model.Node
 import it.unibo.alchemist.model.NodeProperty
 import it.unibo.alchemist.model.Reaction
 import it.unibo.alchemist.model.Time
+import it.unibo.alchemist.model.observation.Disposable
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableMutableMap
 import java.util.Collections
@@ -103,7 +104,9 @@ constructor(
     }
 
     final override fun removeReaction(reactionToRemove: Reaction<T>) {
-        reactions.remove(reactionToRemove)
+        if (reactions.remove(reactionToRemove)) {
+            reactionToRemove.dispose()
+        }
     }
 
     override fun setConcentration(molecule: Molecule, concentration: T) {
@@ -128,6 +131,13 @@ constructor(
 
     override fun toString(): String = "Node$id{ properties: $properties, molecules: ${observableContents.current}}"
 
+    override fun dispose() {
+        reactions.forEach(Disposable::dispose)
+        reactions.clear()
+        observableContents.dispose()
+        observeMoleculeCount.dispose()
+    }
+
     private companion object {
         private const val serialVersionUID = 2496775909028222278L
 
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
index 53c3b6f827..b08e957154 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/reactions/SAPEREGradient.java
@@ -27,6 +27,7 @@
 import it.unibo.alchemist.model.Time;
 import it.unibo.alchemist.model.TimeDistribution;
 import it.unibo.alchemist.model.maps.MapEnvironment;
+import it.unibo.alchemist.model.observation.Disposable;
 import it.unibo.alchemist.model.observation.MutableObservable;
 import it.unibo.alchemist.model.observation.Observable;
 import it.unibo.alchemist.model.observation.ObservableMutableSet;
@@ -366,6 +367,12 @@ public double getRate() {
         return canRun ? getTimeDistribution().getRate() : 0;
     }
 
+    @Override
+    public void dispose() {
+        fakeconds.forEach(Disposable::dispose);
+        super.dispose();
+    }
+
     @Override
     protected void updateInternalStatus(
         final Time currentTime,
diff --git a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
index e599a73472..b2ffec89a6 100644
--- a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
+++ b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
@@ -111,6 +111,14 @@ class PhysicsUpdate<T>(
 
     override fun initializationComplete(atTime: Time, environment: Environment<T, *>) = Unit
 
+    override fun dispose() {
+        subscriptions.forEach { it.stopWatching(this) }
+        subscriptions.clear()
+        validity.dispose()
+        conditions.forEach(Disposable::dispose)
+        rescheduleRequest.dispose()
+    }
+
     private companion object {
         const val DEFAULT_RATE = 30.0
     }
diff --git a/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt b/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
index 15605822d8..3721719d1e 100644
--- a/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
+++ b/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
@@ -57,4 +57,11 @@ class GlobalTestReaction<T>(val environment: Environment<T, *>, override val tim
     override fun update(currentTime: Time, hasBeenExecuted: Boolean, environment: Environment<T, *>) = Unit
 
     override fun initializationComplete(atTime: Time, environment: Environment<T, *>) = Unit
+
+    override fun dispose() {
+        observableConditions.dispose()
+        validity.dispose()
+        conditions.forEach(Condition<T>::dispose)
+        rescheduleRequest.dispose()
+    }
 }

From 02585df678db900245c7fa9663dbfa0ecefcf9c6 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 29 Jan 2026 11:02:36 +0100
Subject: [PATCH 14/29] chore: try avoid memory leaks for region observers

---
 .../model/environments/AbstractEnvironment.kt | 31 ++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
index 036aea8cda..24509023f3 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
@@ -249,7 +249,14 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
                 .put(range, region)
         }
 
-        return initialNodes
+        return AutoDisposableObservableSet(initialNodes) {
+            regionObservers.remove(region)
+            if (node != null) {
+                regionNodeCenteredIndex[node.id]?.remove(range)
+            } else {
+                regionPositionCenteredIndex[actualCenter]?.remove(range)
+            }
+        }
     }
 
     override fun getDistanceBetweenNodes(n1: Node<T>, n2: Node<T>): Double =
@@ -575,6 +582,28 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
         val visibleNodes: ObservableMutableSet<Node<T>>,
     )
 
+    /**
+     * Simple [ObservableSet] that should prevent basic memory leaks. Simply calls [onDispose] when
+     * no observers observe this structure.
+     */
+    private class AutoDisposableObservableSet<T>(
+        private val delegate: ObservableSet<T>,
+        private val onDispose: () -> Unit,
+    ) : ObservableSet<T> by delegate {
+
+        override fun stopWatching(registrant: Any) {
+            delegate.stopWatching(registrant)
+            if (delegate.observers.isEmpty()) {
+                onDispose()
+            }
+        }
+
+        override fun dispose() {
+            delegate.dispose()
+            onDispose()
+        }
+    }
+
     private data class Operation<T>(val origin: Node<T>, val destination: Node<T>, val isAdd: Boolean) {
         override fun toString(): String = origin.toString() + (if (isAdd) " discovered " else " lost ") + destination
     }

From d5a4786d6efa702cea7d057ad7424e28c621e054 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 29 Jan 2026 16:41:02 +0100
Subject: [PATCH 15/29] feat(api): improve lapsed listener problem avoidance
 with `Lifecycle`

This idea is borrowed by Androidx, where by means of Lifecycle state machines we are able to bound the lifecycle of the dependencies to the lifecycle of the owner (i.e. the registrant), properly disposing and releasing observers references withtout using weak references, hence not impacting too much negatively performance.
---
 .../it/unibo/alchemist/model/Actionable.kt    |   4 +-
 .../kotlin/it/unibo/alchemist/model/Node.kt   |   4 +-
 .../alchemist/model/observation/Lifecycle.kt  | 146 ++++++++++++++++++
 .../model/observation/LifecycleTest.kt        | 120 ++++++++++++++
 .../kotlin/it/unibo/alchemist/core/Engine.kt  |   4 +-
 .../model/reactions/AbstractReaction.java     |  40 ++---
 .../model/environments/AbstractEnvironment.kt |  79 +++++++---
 .../alchemist/model/nodes/GenericNode.kt      |   9 ++
 .../model/incarnations/ProtelisIncarnation.kt |   5 +
 .../model/physics/reactions/PhysicsUpdate.kt  |  26 ++--
 .../alchemist/test/GlobalTestReaction.kt      |   9 +-
 11 files changed, 387 insertions(+), 59 deletions(-)
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Lifecycle.kt
 create mode 100644 alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LifecycleTest.kt

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
index b443bbdd62..5304e81b9c 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
@@ -10,6 +10,7 @@
 package it.unibo.alchemist.model
 
 import it.unibo.alchemist.model.observation.Disposable
+import it.unibo.alchemist.model.observation.LifecycleOwner
 import it.unibo.alchemist.model.observation.Observable
 import java.io.Serializable
 import org.danilopianini.util.ListSet
@@ -20,7 +21,8 @@ import org.danilopianini.util.ListSet
 sealed interface Actionable<T> :
     Comparable<Actionable<T>>,
     Serializable,
-    Disposable {
+    Disposable,
+    LifecycleOwner {
     /**
      * @return true if the reaction can be executed (namely, all the conditions
      * are satisfied).
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
index b1fca9a5d4..027d059488 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
@@ -10,6 +10,7 @@ package it.unibo.alchemist.model
 
 import arrow.core.Option
 import it.unibo.alchemist.model.observation.Disposable
+import it.unibo.alchemist.model.observation.LifecycleOwner
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableMap
 import java.io.Serializable
@@ -27,7 +28,8 @@ interface Node<T> :
     Serializable,
     Iterable<Reaction<T>>,
     Comparable<Node<T>>,
-    Disposable {
+    Disposable,
+    LifecycleOwner {
     /**
      * Adds a reaction to this node.
      * The reaction is added only in the node,
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Lifecycle.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Lifecycle.kt
new file mode 100644
index 0000000000..f396f867bd
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Lifecycle.kt
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import it.unibo.alchemist.model.observation.LifecycleState.DESTROYED
+import it.unibo.alchemist.model.observation.LifecycleState.STARTED
+
+/**
+ * Represents the lifecycle state of a component.
+ */
+enum class LifecycleState {
+
+    /**
+     * Destroyed state for a LifecycleOwner. After this state is reached, this Lifecycle will not emit any more events.
+     */
+    DESTROYED,
+
+    /**
+     * Initialized state for a LifecycleOwner.
+     */
+    INITIALIZED,
+
+    /**
+     * Started state for a LifecycleOwner.
+     */
+    STARTED,
+
+    ;
+
+    /**
+     * Checks if the current state is at least the given [state].
+     */
+    fun isAtLeast(state: LifecycleState): Boolean = this >= state
+}
+
+/**
+ * An object which has a [Lifecycle].
+ */
+interface LifecycleOwner {
+
+    /**
+     * The lifecycle of the provider.
+     */
+    val lifecycle: Lifecycle
+}
+
+/**
+ * Manages the state and listeners.
+ */
+interface Lifecycle {
+
+    /**
+     * Returns the current state of the Lifecycle.
+     */
+    val currentState: LifecycleState
+
+    /**
+     * Adds a LifecycleObserver that will be notified when the LifecycleOwner changes state.
+     */
+    fun addObserver(observer: (LifecycleState) -> Unit)
+
+    /**
+     * Removes the given observer from the observers list.
+     */
+    fun removeObserver(observer: (LifecycleState) -> Unit)
+}
+
+/**
+ * A concrete implementation of [Lifecycle] that handles state transitions and observer notification.
+ */
+class LifecycleRegistry : Lifecycle {
+
+    private val observers = mutableListOf<(LifecycleState) -> Unit>()
+
+    override var currentState: LifecycleState = LifecycleState.INITIALIZED
+        private set
+
+    /**
+     * Transitions the lifecycle to a new [state] and notifies all observers.
+     */
+    fun markState(state: LifecycleState) {
+        currentState = state
+        observers.toList().forEach { it(state) }
+    }
+
+    override fun addObserver(observer: (LifecycleState) -> Unit) {
+        observers.add(observer)
+    }
+
+    override fun removeObserver(observer: (LifecycleState) -> Unit) {
+        observers.remove(observer)
+    }
+}
+
+/**
+ * Observes this [Observable] within the context of a [LifecycleOwner]. This
+ * method is a memory-safe alternative to [Observable.onChange] in scenarios
+ * where it is crucial to avoid that the owner subscription leaks. When the
+ * registrant's state reaches [LifecycleState.DESTROYED], the subscription
+ * is automatically removed and cleared up. Moreover, the [callback] is only
+ * invoked if the lifecycle is in an active state ([STARTED]). Finally,
+ * when the lifecycle moves from an inactive state back to active, the
+ * [callback] is triggered immediately with the [Observable.current] value.
+ *
+ * @param lifecycleOwner The object controlling the lifecycle of this subscription.
+ * @param callback The action to perform when the observable emits a value.
+ */
+fun <T> Observable<T>.bindTo(lifecycleOwner: LifecycleOwner, callback: (T) -> Unit) {
+    if (lifecycleOwner.lifecycle.currentState == DESTROYED) return
+
+    val dataListener: (T) -> Unit = { data ->
+        // avoid zombie callbacks
+        if (lifecycleOwner.lifecycle.currentState.isAtLeast(STARTED)) {
+            callback(data)
+        }
+    }
+
+    var lifecycleObserver: ((LifecycleState) -> Unit)? = null
+    lifecycleObserver = { state ->
+        when (state) {
+            DESTROYED -> {
+                this.stopWatching(lifecycleOwner)
+                lifecycleObserver?.let { lifecycleOwner.lifecycle.removeObserver(it) }
+            }
+            STARTED -> callback(this.current)
+            else -> { /* No action needed for other states */ }
+        }
+    }
+
+    lifecycleOwner.lifecycle.addObserver(lifecycleObserver)
+
+    // set `invokeOnRegistration = false` because we handle the initial data emission manually below
+    // to strictly respect the `isAtLeast(STARTED)` check.
+    this.onChange(lifecycleOwner, invokeOnRegistration = false, callback = dataListener)
+
+    if (lifecycleOwner.lifecycle.currentState.isAtLeast(STARTED)) {
+        callback(this.current)
+    }
+}
diff --git a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LifecycleTest.kt b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LifecycleTest.kt
new file mode 100644
index 0000000000..0f331048ad
--- /dev/null
+++ b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LifecycleTest.kt
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.collections.shouldContain
+import io.kotest.matchers.collections.shouldNotContain
+import io.kotest.matchers.shouldBe
+import it.unibo.alchemist.model.observation.LifecycleState.DESTROYED
+import it.unibo.alchemist.model.observation.LifecycleState.STARTED
+import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
+
+class LifecycleTest : FunSpec({
+
+    class TestLifecycleOwner : LifecycleOwner {
+        private val registry = LifecycleRegistry()
+        override val lifecycle: Lifecycle get() = registry
+
+        fun start() = registry.markState(STARTED)
+        fun destroy() = registry.markState(DESTROYED)
+    }
+
+    context("Lifecycle binding tests") {
+
+        test("bindTo should not invoke callback if Lifecycle is INITIALIZED") {
+            val owner = TestLifecycleOwner()
+            val observable = observe(10)
+            var lastValue = -1
+
+            observable.bindTo(owner) { lastValue = it }
+
+            lastValue shouldBe -1
+            observable.current = 20
+            lastValue shouldBe -1
+        }
+
+        test("bindTo should invoke callback immediately if Lifecycle is STARTED") {
+            val owner = TestLifecycleOwner()
+            owner.start()
+            val observable = observe(10)
+            var lastValue = -1
+
+            observable.bindTo(owner) { lastValue = it }
+
+            lastValue shouldBe 10
+        }
+
+        test("bindTo should start receiving updates when Lifecycle moves to STARTED") {
+            val owner = TestLifecycleOwner()
+            val observable = observe(10)
+            var lastValue = -1
+
+            observable.bindTo(owner) { lastValue = it }
+
+            observable.current = 20
+            lastValue shouldBe -1
+
+            owner.start()
+            lastValue shouldBe 20
+
+            observable.current = 30
+            lastValue shouldBe 30
+        }
+
+        test("bindTo should automatically unsubscribe when Lifecycle is DESTROYED") {
+            val owner = TestLifecycleOwner()
+            owner.start()
+            val observable = observe(10)
+            var lastValue = -1
+
+            observable.bindTo(owner) { lastValue = it }
+
+            observable.observers shouldContain owner
+
+            owner.destroy()
+
+            observable.observers shouldNotContain owner
+
+            observable.current = 40
+            lastValue shouldBe 10
+        }
+
+        test("bindTo should not subscribe at all if Lifecycle is already DESTROYED") {
+            val owner = TestLifecycleOwner()
+            owner.destroy()
+            val observable = observe(10)
+
+            observable.bindTo(owner) { }
+
+            observable.observers shouldNotContain owner
+        }
+
+        test("Multiple bindings to the same owner should work independently") {
+            val owner = TestLifecycleOwner()
+            owner.start()
+            val obs1 = observe(1)
+            val obs2 = observe(2)
+            var val1 = -1
+            var val2 = -1
+
+            obs1.bindTo(owner) { val1 = it }
+            obs2.bindTo(owner) { val2 = it }
+
+            val1 shouldBe 1
+            val2 shouldBe 2
+
+            owner.destroy()
+
+            obs1.observers shouldNotContain owner
+            obs2.observers shouldNotContain owner
+        }
+    }
+})
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
index 59685369fa..231fd85a93 100644
--- a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
+++ b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
@@ -75,8 +75,10 @@ open class Engine<T, P : Position<out P>>(
     }
 
     override fun nodeRemoved(node: Node<T>, oldNeighborhood: Neighborhood<T>) {
+        // copy of reactions due to how [GenericNode.dispose] clears the reactions
+        val reactions = ArrayList(node.reactions)
         schedule {
-            node.reactions.forEach { removeReaction(it) }
+            reactions.forEach { removeReaction(it) }
         }
     }
 
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
index e7f4eca92d..332448220c 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
@@ -24,6 +24,11 @@
 import it.unibo.alchemist.model.TimeDistribution;
 import it.unibo.alchemist.model.observation.Disposable;
 import it.unibo.alchemist.model.observation.EventObservable;
+import it.unibo.alchemist.model.observation.Lifecycle;
+import it.unibo.alchemist.model.observation.LifecycleKt;
+import it.unibo.alchemist.model.observation.LifecycleOwner;
+import it.unibo.alchemist.model.observation.LifecycleRegistry;
+import it.unibo.alchemist.model.observation.LifecycleState;
 import it.unibo.alchemist.model.observation.MutableObservable;
 import it.unibo.alchemist.model.observation.Observable;
 import it.unibo.alchemist.model.observation.ObservableExtensions;
@@ -56,7 +61,7 @@
  *
  * @param <T> concentration type
  */
-public abstract class AbstractReaction<T> implements Reaction<T>, Disposable {
+public abstract class AbstractReaction<T> implements Reaction<T>, Disposable, LifecycleOwner {
 
     /**
      * How bigger should be the StringBuffer with respect to the previous
@@ -78,13 +83,13 @@ public abstract class AbstractReaction<T> implements Reaction<T>, Disposable {
     private final TimeDistribution<T> timeDistribution;
     private final Node<T> node;
 
+    private final LifecycleRegistry lifecycleRegistry = new LifecycleRegistry();
     private final EventObservable rescheduleRequest = new EventObservable();
     private Observable<Boolean> validity = MutableObservable.Companion.observe(true);
-    private final List<Observable<?>> subscriptions = new ArrayList<>();
     private Option<Boolean> canExecute = none();
 
     /**
-     * Builds a new reaction, starting at time t.
+     * Builds a new reaction, starting   at time t.
      *
      * @param node             the node this reaction belongs to
      * @param timeDistribution the time distribution this reaction should follow
@@ -143,6 +148,13 @@ public final boolean equals(final Object o) {
         return this == o;
     }
 
+    @NotNull
+    @Override
+    @SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "This is intentional")
+    public final Lifecycle getLifecycle() {
+        return lifecycleRegistry;
+    }
+
     /**
      * The default execution iterates all the actions in order and executes them. Override to change the behavior.
      */
@@ -244,6 +256,7 @@ public final int hashCode() {
     @Override
     public final void initializationComplete(@Nonnull final Time atTime, @Nonnull final Environment<T, ?> environment) {
         initializeObservableConditions();
+        lifecycleRegistry.markState(LifecycleState.STARTED);
         onInitializationComplete(atTime, environment);
     }
 
@@ -344,22 +357,16 @@ public void setConditions(@Nonnull final List<? extends Condition<T>> conditions
      * trigger some environment query that may fail in the set-up phase.
      */
     protected final void initializeObservableConditions() {
-        if (!subscriptions.isEmpty()) {
-            subscriptions.forEach(s -> s.stopWatching(this));
-            subscriptions.clear();
-        }
-
         validity.dispose();
 
         conditions.forEach(condition -> {
             final var merged = ObservableExtensions.ObservableSetExtensions.mergeObservables(
                 condition.observeInboundDependencies()
             );
-            merged.onChange(this, it -> {
+            LifecycleKt.bindTo(merged, this, it -> {
                 rescheduleRequest.emit();
-                return null;
+                return Unit.INSTANCE;
             });
-            subscriptions.add(merged);
         });
 
         if (!conditions.isEmpty()) {
@@ -368,15 +375,11 @@ protected final void initializeObservableConditions() {
                 it -> it.stream().allMatch(b -> b)
             ).map(it -> getOrElse(it, () -> true));
 
-            // need at least one observer to track validity updates
-            validity.onChange(this, it -> {
+            LifecycleKt.bindTo(validity, this, it -> {
                 canExecute = Option.fromNullable(it);
-                return null;
+                return Unit.INSTANCE;
             });
-
-            subscriptions.add(validity);
         }
-
         rescheduleRequest.emit();
     }
 
@@ -437,10 +440,9 @@ public final void update(
      */
     @Override
     public void dispose() {
-        subscriptions.forEach(it -> it.stopWatching(this));
+        lifecycleRegistry.markState(LifecycleState.DESTROYED);
         conditions.forEach(Disposable::dispose);
         conditions.clear();
-        subscriptions.clear();
     }
 
     /**
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
index 24509023f3..c6653f30cc 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/environments/AbstractEnvironment.kt
@@ -27,7 +27,6 @@ import it.unibo.alchemist.model.Position
 import it.unibo.alchemist.model.SupportedIncarnations
 import it.unibo.alchemist.model.TerminationPredicate
 import it.unibo.alchemist.model.linkingrules.NoLinks
-import it.unibo.alchemist.model.observation.Disposable
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableMutableMap
 import it.unibo.alchemist.model.observation.ObservableMutableSet
@@ -234,29 +233,50 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
             centerProvider = centerProvider,
             radius = range,
             visibleNodes = initialNodes,
-        ).apply { regionObservers.add(this) }
-
-        if (node != null) {
-            var radiusMap = regionNodeCenteredIndex[node.id]
-            if (radiusMap == null) {
-                radiusMap = TDoubleObjectHashMap()
-                regionNodeCenteredIndex.put(node.id, radiusMap)
-            }
-            radiusMap.put(range, region)
-        } else {
-            regionPositionCenteredIndex
-                .computeIfAbsent(actualCenter) { TDoubleObjectHashMap() }
-                .put(range, region)
+        )
+
+        val addRegion = {
+            runCatching {
+                val currentCenter = centerProvider()
+                val currentNodes = getAllNodesInRange(currentCenter, range)
+                initialNodes.clearAndAddAll(currentNodes.toSet())
+
+                regionObservers.add(region)
+                if (node != null) {
+                    var radiusMap = regionNodeCenteredIndex[node.id]
+                    if (radiusMap == null) {
+                        radiusMap = TDoubleObjectHashMap()
+                        regionNodeCenteredIndex.put(node.id, radiusMap)
+                    }
+                    radiusMap.put(range, region)
+                } else {
+                    regionPositionCenteredIndex
+                        .computeIfAbsent(actualCenter) { TDoubleObjectHashMap() }
+                        .put(range, region)
+                }
+            }.onFailure { initialNodes.clearAndAddAll(emptySet()) }
         }
 
-        return AutoDisposableObservableSet(initialNodes) {
+        val removeRegion = {
             regionObservers.remove(region)
             if (node != null) {
                 regionNodeCenteredIndex[node.id]?.remove(range)
+                if (regionNodeCenteredIndex[node.id]?.isEmpty == true) {
+                    regionNodeCenteredIndex.remove(node.id)
+                }
             } else {
                 regionPositionCenteredIndex[actualCenter]?.remove(range)
+                if (regionPositionCenteredIndex[actualCenter]?.isEmpty == true) {
+                    regionPositionCenteredIndex.remove(actualCenter)
+                }
             }
         }
+
+        return RefCountObservableSet(
+            delegate = initialNodes,
+            onActive = { addRegion() },
+            onInactive = { removeRegion() },
+        )
     }
 
     override fun getDistanceBetweenNodes(n1: Node<T>, n2: Node<T>): Double =
@@ -583,24 +603,39 @@ abstract class AbstractEnvironment<T, P : Position<P>> protected constructor(
     )
 
     /**
-     * Simple [ObservableSet] that should prevent basic memory leaks. Simply calls [onDispose] when
-     * no observers observe this structure.
+     * Simple wrapper for [ObservableSet] that manages reference counting to track observers and
+     * invoke specified callbacks when observers are registered or deregistered.
+     * It serves as both a way to avoid leaks through the [onInactive] callback (which should clear
+     * the backing caches), and a lazy evaluation of [onActive] when observers are registered.
+     *
+     *
+     * @param onActive the callback to be invoked when the first observer is added
+     * @param onInactive the callback to be invoked when the last observer is removed, which
+     *                   should clear backing caches and resources.
      */
-    private class AutoDisposableObservableSet<T>(
-        private val delegate: ObservableSet<T>,
-        private val onDispose: () -> Unit,
+    private class RefCountObservableSet<T>(
+        private val delegate: ObservableMutableSet<T>,
+        private val onActive: () -> Unit,
+        private val onInactive: () -> Unit,
     ) : ObservableSet<T> by delegate {
 
+        override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (Set<T>) -> Unit) {
+            if (delegate.observers.isEmpty()) {
+                onActive()
+            }
+            delegate.onChange(registrant, invokeOnRegistration, callback)
+        }
+
         override fun stopWatching(registrant: Any) {
             delegate.stopWatching(registrant)
             if (delegate.observers.isEmpty()) {
-                onDispose()
+                onInactive()
             }
         }
 
         override fun dispose() {
             delegate.dispose()
-            onDispose()
+            onInactive()
         }
     }
 
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
index 9592fae0a5..d92f9d66de 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
@@ -18,6 +18,8 @@ import it.unibo.alchemist.model.NodeProperty
 import it.unibo.alchemist.model.Reaction
 import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.observation.Disposable
+import it.unibo.alchemist.model.observation.LifecycleRegistry
+import it.unibo.alchemist.model.observation.LifecycleState
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableMutableMap
 import java.util.Collections
@@ -49,6 +51,12 @@ constructor(
     final override val properties: MutableList<NodeProperty<T>> = ArrayList(),
 ) : Node<T> {
 
+    override val lifecycle: LifecycleRegistry = LifecycleRegistry()
+
+    init {
+        lifecycle.markState(LifecycleState.STARTED)
+    }
+
     override val observableContents: ObservableMutableMap<Molecule, T> = ObservableMutableMap(molecules)
 
     override val observeMoleculeCount: Observable<Int> = observableContents.map { it.size }
@@ -132,6 +140,7 @@ constructor(
     override fun toString(): String = "Node$id{ properties: $properties, molecules: ${observableContents.current}}"
 
     override fun dispose() {
+        lifecycle.markState(LifecycleState.DESTROYED)
         reactions.forEach(Disposable::dispose)
         reactions.clear()
         observableContents.dispose()
diff --git a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt
index 351b553e5c..21288e748e 100644
--- a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt
+++ b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt
@@ -29,6 +29,7 @@ import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.TimeDistribution
 import it.unibo.alchemist.model.molecules.SimpleMolecule
 import it.unibo.alchemist.model.nodes.GenericNode
+import it.unibo.alchemist.model.observation.LifecycleRegistry
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableMap
 import it.unibo.alchemist.model.protelis.actions.RunProtelisProgram
@@ -373,6 +374,8 @@ class ProtelisIncarnation<P : Position<P>> : Incarnation<Any, P> {
 
         override val reactions: List<Reaction<Any>> = emptyList()
 
+        override val lifecycle: LifecycleRegistry = LifecycleRegistry()
+
         override fun iterator(): MutableIterator<Reaction<Any>> = notImplemented()
 
         override fun compareTo(@Nonnull other: Node<Any>): Int = notImplemented()
@@ -395,6 +398,8 @@ class ProtelisIncarnation<P : Position<P>> : Incarnation<Any, P> {
 
         override fun setConcentration(molecule: Molecule, concentration: Any) = notImplemented<Unit>()
 
+        override fun dispose() = notImplemented<Unit>()
+
         override fun addProperty(nodeProperty: NodeProperty<Any>) = notImplemented<Unit>()
 
         /**
diff --git a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
index b2ffec89a6..e59b9112f6 100644
--- a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
+++ b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
@@ -20,14 +20,16 @@ import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.TimeDistribution
 import it.unibo.alchemist.model.observation.Disposable
 import it.unibo.alchemist.model.observation.EventObservable
+import it.unibo.alchemist.model.observation.LifecycleRegistry
+import it.unibo.alchemist.model.observation.LifecycleState
 import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.merge
 import it.unibo.alchemist.model.observation.ObservableExtensions.combineLatest
+import it.unibo.alchemist.model.observation.bindTo
 import it.unibo.alchemist.model.physics.PhysicsDependency
 import it.unibo.alchemist.model.physics.environments.Dynamics2DEnvironment
 import it.unibo.alchemist.model.timedistributions.DiracComb
-import java.util.ArrayList
 import org.danilopianini.util.ImmutableListSet
 import org.danilopianini.util.ListSet
 
@@ -59,28 +61,24 @@ class PhysicsUpdate<T>(
 
     override val rescheduleRequest: EventObservable = EventObservable()
 
+    override val lifecycle: LifecycleRegistry = LifecycleRegistry()
+
     override var actions: List<Action<T>> = listOf()
 
     private var validity: Observable<Boolean> = observe(true)
 
     private var canExecute: Boolean = true
 
-    private val subscriptions: MutableList<Observable<*>> = ArrayList()
-
     override var conditions: List<Condition<T>> = listOf()
         set(value) {
             field = value
             field.forEach(Disposable::dispose)
 
-            subscriptions.forEach { it.stopWatching(this) }
-            subscriptions.clear()
-
             validity.dispose()
 
             value.forEach { condition ->
-                condition.observeInboundDependencies().merge().apply {
-                    onChange(this@PhysicsUpdate) { rescheduleRequest.emit() }
-                    subscriptions.add(this)
+                condition.observeInboundDependencies().merge().bindTo(this) {
+                    rescheduleRequest.emit()
                 }
             }
 
@@ -89,8 +87,7 @@ class PhysicsUpdate<T>(
                 ?.combineLatest { validities -> validities.all { it } }
                 ?.map { it.getOrElse { true } } // none means empty set of conditions i.e. always true.
                 ?.apply {
-                    onChange(this@PhysicsUpdate) { canExecute = it }
-                    subscriptions.add(this)
+                    bindTo(this@PhysicsUpdate) { canExecute = it }
                 } ?: observe(true)
 
             rescheduleRequest.emit()
@@ -109,11 +106,12 @@ class PhysicsUpdate<T>(
 
     override fun update(currentTime: Time, hasBeenExecuted: Boolean, environment: Environment<T, *>) = Unit
 
-    override fun initializationComplete(atTime: Time, environment: Environment<T, *>) = Unit
+    override fun initializationComplete(atTime: Time, environment: Environment<T, *>) {
+        lifecycle.markState(LifecycleState.STARTED)
+    }
 
     override fun dispose() {
-        subscriptions.forEach { it.stopWatching(this) }
-        subscriptions.clear()
+        lifecycle.markState(LifecycleState.DESTROYED)
         validity.dispose()
         conditions.forEach(Disposable::dispose)
         rescheduleRequest.dispose()
diff --git a/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt b/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
index 3721719d1e..b638d92588 100644
--- a/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
+++ b/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
@@ -18,6 +18,8 @@ import it.unibo.alchemist.model.GlobalReaction
 import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.TimeDistribution
 import it.unibo.alchemist.model.observation.EventObservable
+import it.unibo.alchemist.model.observation.LifecycleRegistry
+import it.unibo.alchemist.model.observation.LifecycleState
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.combineLatest
 import it.unibo.alchemist.model.observation.ObservableMutableSet
@@ -36,6 +38,8 @@ class GlobalTestReaction<T>(val environment: Environment<T, *>, override val tim
 
     override var actions: List<Action<T>> = emptyList()
 
+    override val lifecycle: LifecycleRegistry = LifecycleRegistry()
+
     override var conditions: List<Condition<T>> = emptyList()
         set(value) {
             field = value
@@ -56,9 +60,12 @@ class GlobalTestReaction<T>(val environment: Environment<T, *>, override val tim
 
     override fun update(currentTime: Time, hasBeenExecuted: Boolean, environment: Environment<T, *>) = Unit
 
-    override fun initializationComplete(atTime: Time, environment: Environment<T, *>) = Unit
+    override fun initializationComplete(atTime: Time, environment: Environment<T, *>) {
+        lifecycle.markState(LifecycleState.STARTED)
+    }
 
     override fun dispose() {
+        lifecycle.markState(LifecycleState.DESTROYED)
         observableConditions.dispose()
         validity.dispose()
         conditions.forEach(Condition<T>::dispose)

From e65ac89ef3646061c541b79f859a9e7746dd1b3e Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Fri, 30 Jan 2026 16:23:37 +0100
Subject: [PATCH 16/29] chore(api): cleanup conditions if conditions are set
 mulitple times

---
 .../alchemist/model/observation/Lifecycle.kt  | 53 ++++++++++---------
 .../model/reactions/AbstractReaction.java     | 13 +++--
 2 files changed, 38 insertions(+), 28 deletions(-)

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Lifecycle.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Lifecycle.kt
index f396f867bd..ed89be4395 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Lifecycle.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Lifecycle.kt
@@ -111,36 +111,41 @@ class LifecycleRegistry : Lifecycle {
  *
  * @param lifecycleOwner The object controlling the lifecycle of this subscription.
  * @param callback The action to perform when the observable emits a value.
+ * @return a [Disposable] to manually dispose the subscription outside owner's lifecycle.
  */
-fun <T> Observable<T>.bindTo(lifecycleOwner: LifecycleOwner, callback: (T) -> Unit) {
-    if (lifecycleOwner.lifecycle.currentState == DESTROYED) return
-
-    val dataListener: (T) -> Unit = { data ->
-        // avoid zombie callbacks
-        if (lifecycleOwner.lifecycle.currentState.isAtLeast(STARTED)) {
-            callback(data)
+fun <T> Observable<T>.bindTo(lifecycleOwner: LifecycleOwner, callback: (T) -> Unit): Disposable? =
+    lifecycleOwner.takeIf { it.lifecycle.currentState != DESTROYED }?.let {
+        val dataListener: (T) -> Unit = { data ->
+            // avoid zombie callbacks
+            if (lifecycleOwner.lifecycle.currentState.isAtLeast(STARTED)) {
+                callback(data)
+            }
         }
-    }
 
-    var lifecycleObserver: ((LifecycleState) -> Unit)? = null
-    lifecycleObserver = { state ->
-        when (state) {
-            DESTROYED -> {
-                this.stopWatching(lifecycleOwner)
-                lifecycleObserver?.let { lifecycleOwner.lifecycle.removeObserver(it) }
+        var lifecycleObserver: ((LifecycleState) -> Unit)? = null
+        lifecycleObserver = { state ->
+            when (state) {
+                DESTROYED -> {
+                    this.stopWatching(lifecycleOwner)
+                    lifecycleObserver?.let { lifecycleOwner.lifecycle.removeObserver(it) }
+                }
+                STARTED -> callback(this.current)
+                else -> { /* No action needed for other states */ }
             }
-            STARTED -> callback(this.current)
-            else -> { /* No action needed for other states */ }
         }
-    }
 
-    lifecycleOwner.lifecycle.addObserver(lifecycleObserver)
+        lifecycleOwner.lifecycle.addObserver(lifecycleObserver)
 
-    // set `invokeOnRegistration = false` because we handle the initial data emission manually below
-    // to strictly respect the `isAtLeast(STARTED)` check.
-    this.onChange(lifecycleOwner, invokeOnRegistration = false, callback = dataListener)
+        // set `invokeOnRegistration = false` because we handle the initial data emission manually below
+        // to strictly respect the `isAtLeast(STARTED)` check.
+        this.onChange(lifecycleOwner, invokeOnRegistration = false, callback = dataListener)
 
-    if (lifecycleOwner.lifecycle.currentState.isAtLeast(STARTED)) {
-        callback(this.current)
+        if (lifecycleOwner.lifecycle.currentState.isAtLeast(STARTED)) {
+            callback(this.current)
+        }
+
+        return Disposable {
+            this@bindTo.stopWatching(dataListener)
+            lifecycleOwner.lifecycle.removeObserver(lifecycleObserver)
+        }
     }
-}
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
index 332448220c..d580226b27 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
@@ -83,6 +83,7 @@ public abstract class AbstractReaction<T> implements Reaction<T>, Disposable, Li
     private final TimeDistribution<T> timeDistribution;
     private final Node<T> node;
 
+    private final List<Disposable> subscriptions = new ArrayList<>(0);
     private final LifecycleRegistry lifecycleRegistry = new LifecycleRegistry();
     private final EventObservable rescheduleRequest = new EventObservable();
     private Observable<Boolean> validity = MutableObservable.Companion.observe(true);
@@ -357,16 +358,18 @@ public void setConditions(@Nonnull final List<? extends Condition<T>> conditions
      * trigger some environment query that may fail in the set-up phase.
      */
     protected final void initializeObservableConditions() {
+        subscriptions.forEach(Disposable::dispose);
+        subscriptions.clear();
         validity.dispose();
 
         conditions.forEach(condition -> {
             final var merged = ObservableExtensions.ObservableSetExtensions.mergeObservables(
                 condition.observeInboundDependencies()
             );
-            LifecycleKt.bindTo(merged, this, it -> {
+            subscriptions.add(LifecycleKt.bindTo(merged, this, it -> {
                 rescheduleRequest.emit();
                 return Unit.INSTANCE;
-            });
+            }));
         });
 
         if (!conditions.isEmpty()) {
@@ -375,10 +378,10 @@ protected final void initializeObservableConditions() {
                 it -> it.stream().allMatch(b -> b)
             ).map(it -> getOrElse(it, () -> true));
 
-            LifecycleKt.bindTo(validity, this, it -> {
+            subscriptions.add(LifecycleKt.bindTo(validity, this, it -> {
                 canExecute = Option.fromNullable(it);
                 return Unit.INSTANCE;
-            });
+            }));
         }
         rescheduleRequest.emit();
     }
@@ -441,8 +444,10 @@ public final void update(
     @Override
     public void dispose() {
         lifecycleRegistry.markState(LifecycleState.DESTROYED);
+        subscriptions.forEach(Disposable::dispose);
         conditions.forEach(Disposable::dispose);
         conditions.clear();
+        subscriptions.clear();
     }
 
     /**

From 4a75a5181a5f3321df2fb417de7a4c27bf3c7d69 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Tue, 10 Feb 2026 10:33:50 +0100
Subject: [PATCH 17/29] refactor(api): extract lifecycle components into
 multiple files

---
 .../it/unibo/alchemist/model/Actionable.kt    |  2 +-
 .../kotlin/it/unibo/alchemist/model/Node.kt   |  2 +-
 .../model/observation/lifecycle/Lifecycle.kt  | 31 +++++++
 .../LifecycleOwner.kt}                        | 92 ++-----------------
 .../lifecycle/LifecycleRegistry.kt            | 37 ++++++++
 .../observation/lifecycle/LifecycleState.kt   | 38 ++++++++
 .../model/observation/LifecycleTest.kt        |  8 +-
 .../model/reactions/AbstractReaction.java     | 14 +--
 .../alchemist/model/nodes/GenericNode.kt      |  4 +-
 .../model/incarnations/ProtelisIncarnation.kt |  2 +-
 .../model/physics/reactions/PhysicsUpdate.kt  |  6 +-
 .../alchemist/test/GlobalTestReaction.kt      |  4 +-
 12 files changed, 138 insertions(+), 102 deletions(-)
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/Lifecycle.kt
 rename alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/{Lifecycle.kt => lifecycle/LifecycleOwner.kt} (52%)
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleRegistry.kt
 create mode 100644 alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleState.kt

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
index 5304e81b9c..8eb3606f93 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Actionable.kt
@@ -10,8 +10,8 @@
 package it.unibo.alchemist.model
 
 import it.unibo.alchemist.model.observation.Disposable
-import it.unibo.alchemist.model.observation.LifecycleOwner
 import it.unibo.alchemist.model.observation.Observable
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleOwner
 import java.io.Serializable
 import org.danilopianini.util.ListSet
 
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
index 027d059488..a1b0f059a7 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/Node.kt
@@ -10,9 +10,9 @@ package it.unibo.alchemist.model
 
 import arrow.core.Option
 import it.unibo.alchemist.model.observation.Disposable
-import it.unibo.alchemist.model.observation.LifecycleOwner
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableMap
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleOwner
 import java.io.Serializable
 import kotlin.reflect.KClass
 import kotlin.reflect.full.isSubclassOf
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/Lifecycle.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/Lifecycle.kt
new file mode 100644
index 0000000000..ebd24fa226
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/Lifecycle.kt
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation.lifecycle
+
+/**
+ * Manages the state and listeners.
+ */
+interface Lifecycle {
+
+    /**
+     * Returns the current state of the Lifecycle.
+     */
+    val currentState: LifecycleState
+
+    /**
+     * Adds a LifecycleObserver that will be notified when the LifecycleOwner changes state.
+     */
+    fun addObserver(observer: (LifecycleState) -> Unit)
+
+    /**
+     * Removes the given observer from the observers list.
+     */
+    fun removeObserver(observer: (LifecycleState) -> Unit)
+}
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Lifecycle.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleOwner.kt
similarity index 52%
rename from alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Lifecycle.kt
rename to alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleOwner.kt
index ed89be4395..bedff28e11 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/Lifecycle.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleOwner.kt
@@ -7,38 +7,12 @@
  * as described in the file LICENSE in the Alchemist distribution's top directory.
  */
 
-package it.unibo.alchemist.model.observation
+package it.unibo.alchemist.model.observation.lifecycle
 
-import it.unibo.alchemist.model.observation.LifecycleState.DESTROYED
-import it.unibo.alchemist.model.observation.LifecycleState.STARTED
-
-/**
- * Represents the lifecycle state of a component.
- */
-enum class LifecycleState {
-
-    /**
-     * Destroyed state for a LifecycleOwner. After this state is reached, this Lifecycle will not emit any more events.
-     */
-    DESTROYED,
-
-    /**
-     * Initialized state for a LifecycleOwner.
-     */
-    INITIALIZED,
-
-    /**
-     * Started state for a LifecycleOwner.
-     */
-    STARTED,
-
-    ;
-
-    /**
-     * Checks if the current state is at least the given [state].
-     */
-    fun isAtLeast(state: LifecycleState): Boolean = this >= state
-}
+import it.unibo.alchemist.model.observation.Disposable
+import it.unibo.alchemist.model.observation.Observable
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleState.DESTROYED
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleState.STARTED
 
 /**
  * An object which has a [Lifecycle].
@@ -52,66 +26,18 @@ interface LifecycleOwner {
 }
 
 /**
- * Manages the state and listeners.
- */
-interface Lifecycle {
-
-    /**
-     * Returns the current state of the Lifecycle.
-     */
-    val currentState: LifecycleState
-
-    /**
-     * Adds a LifecycleObserver that will be notified when the LifecycleOwner changes state.
-     */
-    fun addObserver(observer: (LifecycleState) -> Unit)
-
-    /**
-     * Removes the given observer from the observers list.
-     */
-    fun removeObserver(observer: (LifecycleState) -> Unit)
-}
-
-/**
- * A concrete implementation of [Lifecycle] that handles state transitions and observer notification.
- */
-class LifecycleRegistry : Lifecycle {
-
-    private val observers = mutableListOf<(LifecycleState) -> Unit>()
-
-    override var currentState: LifecycleState = LifecycleState.INITIALIZED
-        private set
-
-    /**
-     * Transitions the lifecycle to a new [state] and notifies all observers.
-     */
-    fun markState(state: LifecycleState) {
-        currentState = state
-        observers.toList().forEach { it(state) }
-    }
-
-    override fun addObserver(observer: (LifecycleState) -> Unit) {
-        observers.add(observer)
-    }
-
-    override fun removeObserver(observer: (LifecycleState) -> Unit) {
-        observers.remove(observer)
-    }
-}
-
-/**
- * Observes this [Observable] within the context of a [LifecycleOwner]. This
- * method is a memory-safe alternative to [Observable.onChange] in scenarios
+ * Observes this [it.unibo.alchemist.model.observation.Observable] within the context of a [LifecycleOwner]. This
+ * method is a memory-safe alternative to [it.unibo.alchemist.model.observation.Observable.onChange] in scenarios
  * where it is crucial to avoid that the owner subscription leaks. When the
  * registrant's state reaches [LifecycleState.DESTROYED], the subscription
  * is automatically removed and cleared up. Moreover, the [callback] is only
  * invoked if the lifecycle is in an active state ([STARTED]). Finally,
  * when the lifecycle moves from an inactive state back to active, the
- * [callback] is triggered immediately with the [Observable.current] value.
+ * [callback] is triggered immediately with the [it.unibo.alchemist.model.observation.Observable.current] value.
  *
  * @param lifecycleOwner The object controlling the lifecycle of this subscription.
  * @param callback The action to perform when the observable emits a value.
- * @return a [Disposable] to manually dispose the subscription outside owner's lifecycle.
+ * @return a [it.unibo.alchemist.model.observation.Disposable] to manually dispose the subscription outside owner's lifecycle.
  */
 fun <T> Observable<T>.bindTo(lifecycleOwner: LifecycleOwner, callback: (T) -> Unit): Disposable? =
     lifecycleOwner.takeIf { it.lifecycle.currentState != DESTROYED }?.let {
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleRegistry.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleRegistry.kt
new file mode 100644
index 0000000000..17d6972dcf
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleRegistry.kt
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation.lifecycle
+
+/**
+ * A concrete implementation of [Lifecycle] that handles state transitions and observer notification.
+ */
+class LifecycleRegistry : Lifecycle {
+
+    private val observers = mutableListOf<(LifecycleState) -> Unit>()
+
+    override var currentState: LifecycleState = LifecycleState.INITIALIZED
+        private set
+
+    /**
+     * Transitions the lifecycle to a new [state] and notifies all observers.
+     */
+    fun markState(state: LifecycleState) {
+        currentState = state
+        observers.toList().forEach { it(state) }
+    }
+
+    override fun addObserver(observer: (LifecycleState) -> Unit) {
+        observers.add(observer)
+    }
+
+    override fun removeObserver(observer: (LifecycleState) -> Unit) {
+        observers.remove(observer)
+    }
+}
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleState.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleState.kt
new file mode 100644
index 0000000000..638c32aef0
--- /dev/null
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleState.kt
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+
+package it.unibo.alchemist.model.observation.lifecycle
+
+/**
+ * Represents the lifecycle state of a component.
+ */
+enum class LifecycleState {
+
+    /**
+     * Destroyed state for a LifecycleOwner. After this state is reached, this Lifecycle will not emit any more events.
+     */
+    DESTROYED,
+
+    /**
+     * Initialized state for a LifecycleOwner.
+     */
+    INITIALIZED,
+
+    /**
+     * Started state for a LifecycleOwner.
+     */
+    STARTED,
+
+    ;
+
+    /**
+     * Checks if the current state is at least the given [state].
+     */
+    fun isAtLeast(state: LifecycleState): Boolean = this >= state
+}
diff --git a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LifecycleTest.kt b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LifecycleTest.kt
index 0f331048ad..6110887c5c 100644
--- a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LifecycleTest.kt
+++ b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/LifecycleTest.kt
@@ -13,9 +13,13 @@ import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.collections.shouldContain
 import io.kotest.matchers.collections.shouldNotContain
 import io.kotest.matchers.shouldBe
-import it.unibo.alchemist.model.observation.LifecycleState.DESTROYED
-import it.unibo.alchemist.model.observation.LifecycleState.STARTED
 import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
+import it.unibo.alchemist.model.observation.lifecycle.Lifecycle
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleOwner
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleRegistry
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleState.DESTROYED
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleState.STARTED
+import it.unibo.alchemist.model.observation.lifecycle.bindTo
 
 class LifecycleTest : FunSpec({
 
diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
index d580226b27..150260eac1 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
@@ -24,11 +24,11 @@
 import it.unibo.alchemist.model.TimeDistribution;
 import it.unibo.alchemist.model.observation.Disposable;
 import it.unibo.alchemist.model.observation.EventObservable;
-import it.unibo.alchemist.model.observation.Lifecycle;
-import it.unibo.alchemist.model.observation.LifecycleKt;
-import it.unibo.alchemist.model.observation.LifecycleOwner;
-import it.unibo.alchemist.model.observation.LifecycleRegistry;
-import it.unibo.alchemist.model.observation.LifecycleState;
+import it.unibo.alchemist.model.observation.lifecycle.Lifecycle;
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleOwner;
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleOwnerKt;
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleRegistry;
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleState;
 import it.unibo.alchemist.model.observation.MutableObservable;
 import it.unibo.alchemist.model.observation.Observable;
 import it.unibo.alchemist.model.observation.ObservableExtensions;
@@ -366,7 +366,7 @@ protected final void initializeObservableConditions() {
             final var merged = ObservableExtensions.ObservableSetExtensions.mergeObservables(
                 condition.observeInboundDependencies()
             );
-            subscriptions.add(LifecycleKt.bindTo(merged, this, it -> {
+            subscriptions.add(LifecycleOwnerKt.bindTo(merged, this, it -> {
                 rescheduleRequest.emit();
                 return Unit.INSTANCE;
             }));
@@ -378,7 +378,7 @@ protected final void initializeObservableConditions() {
                 it -> it.stream().allMatch(b -> b)
             ).map(it -> getOrElse(it, () -> true));
 
-            subscriptions.add(LifecycleKt.bindTo(validity, this, it -> {
+            subscriptions.add(LifecycleOwnerKt.bindTo(validity, this, it -> {
                 canExecute = Option.fromNullable(it);
                 return Unit.INSTANCE;
             }));
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
index d92f9d66de..01daa4caf4 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
@@ -18,10 +18,10 @@ import it.unibo.alchemist.model.NodeProperty
 import it.unibo.alchemist.model.Reaction
 import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.observation.Disposable
-import it.unibo.alchemist.model.observation.LifecycleRegistry
-import it.unibo.alchemist.model.observation.LifecycleState
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableMutableMap
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleRegistry
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleState
 import java.util.Collections
 import java.util.Spliterator
 import java.util.concurrent.Semaphore
diff --git a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt
index 21288e748e..28b1ae2b8e 100644
--- a/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt
+++ b/alchemist-incarnation-protelis/src/main/kotlin/it/unibo/alchemist/model/incarnations/ProtelisIncarnation.kt
@@ -29,9 +29,9 @@ import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.TimeDistribution
 import it.unibo.alchemist.model.molecules.SimpleMolecule
 import it.unibo.alchemist.model.nodes.GenericNode
-import it.unibo.alchemist.model.observation.LifecycleRegistry
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableMap
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleRegistry
 import it.unibo.alchemist.model.protelis.actions.RunProtelisProgram
 import it.unibo.alchemist.model.protelis.actions.SendToNeighbor
 import it.unibo.alchemist.model.protelis.conditions.ComputationalRoundComplete
diff --git a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
index e59b9112f6..91f884520b 100644
--- a/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
+++ b/alchemist-physics/src/main/kotlin/it/unibo/alchemist/model/physics/reactions/PhysicsUpdate.kt
@@ -20,13 +20,13 @@ import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.TimeDistribution
 import it.unibo.alchemist.model.observation.Disposable
 import it.unibo.alchemist.model.observation.EventObservable
-import it.unibo.alchemist.model.observation.LifecycleRegistry
-import it.unibo.alchemist.model.observation.LifecycleState
 import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.merge
 import it.unibo.alchemist.model.observation.ObservableExtensions.combineLatest
-import it.unibo.alchemist.model.observation.bindTo
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleRegistry
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleState
+import it.unibo.alchemist.model.observation.lifecycle.bindTo
 import it.unibo.alchemist.model.physics.PhysicsDependency
 import it.unibo.alchemist.model.physics.environments.Dynamics2DEnvironment
 import it.unibo.alchemist.model.timedistributions.DiracComb
diff --git a/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt b/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
index b638d92588..e69de5731a 100644
--- a/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
+++ b/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/GlobalTestReaction.kt
@@ -18,11 +18,11 @@ import it.unibo.alchemist.model.GlobalReaction
 import it.unibo.alchemist.model.Time
 import it.unibo.alchemist.model.TimeDistribution
 import it.unibo.alchemist.model.observation.EventObservable
-import it.unibo.alchemist.model.observation.LifecycleRegistry
-import it.unibo.alchemist.model.observation.LifecycleState
 import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableExtensions.ObservableSetExtensions.combineLatest
 import it.unibo.alchemist.model.observation.ObservableMutableSet
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleRegistry
+import it.unibo.alchemist.model.observation.lifecycle.LifecycleState
 import org.danilopianini.util.ListSet
 import org.danilopianini.util.ListSets
 

From 327a501ded8576db47d9d49b2807965729d3ac1a Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Tue, 10 Feb 2026 12:00:29 +0100
Subject: [PATCH 18/29] fix: fix line length

---
 .../alchemist/model/observation/lifecycle/LifecycleOwner.kt    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleOwner.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleOwner.kt
index bedff28e11..07f0c80082 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleOwner.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/lifecycle/LifecycleOwner.kt
@@ -37,7 +37,8 @@ interface LifecycleOwner {
  *
  * @param lifecycleOwner The object controlling the lifecycle of this subscription.
  * @param callback The action to perform when the observable emits a value.
- * @return a [it.unibo.alchemist.model.observation.Disposable] to manually dispose the subscription outside owner's lifecycle.
+ * @return a [it.unibo.alchemist.model.observation.Disposable]
+ *         to manually dispose the subscription outside owner's lifecycle.
  */
 fun <T> Observable<T>.bindTo(lifecycleOwner: LifecycleOwner, callback: (T) -> Unit): Disposable? =
     lifecycleOwner.takeIf { it.lifecycle.currentState != DESTROYED }?.let {

From 511af3bc8e1e64a8adb0644667fe6ee4eb990df9 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Fri, 13 Feb 2026 19:02:47 +0100
Subject: [PATCH 19/29] chore(docs): remove useless whitespace

---
 .../it/unibo/alchemist/model/reactions/AbstractReaction.java    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
index 150260eac1..c89a89b9ad 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
@@ -90,7 +90,7 @@ public abstract class AbstractReaction<T> implements Reaction<T>, Disposable, Li
     private Option<Boolean> canExecute = none();
 
     /**
-     * Builds a new reaction, starting   at time t.
+     * Builds a new reaction, starting at time t.
      *
      * @param node             the node this reaction belongs to
      * @param timeDistribution the time distribution this reaction should follow

From 217ceb7ac8778f12386421f534763de7b5ab8e7b Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Sun, 15 Feb 2026 15:56:14 +0100
Subject: [PATCH 20/29] fix(cognitive-agents): use `getCurrentPosition` to
 retireve node's actual position

---
 .../model/cognitive/navigation/ReachKnownDestination.kt       | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/navigation/ReachKnownDestination.kt b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/navigation/ReachKnownDestination.kt
index 3c6af520b7..f116b462e9 100644
--- a/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/navigation/ReachKnownDestination.kt
+++ b/alchemist-cognitive-agents/src/main/kotlin/it/unibo/alchemist/model/cognitive/navigation/ReachKnownDestination.kt
@@ -49,7 +49,7 @@ open class ReachKnownDestination<T, L : Euclidean2DConvexShape, R>(
             emptyList()
         } else {
             with(action) {
-                val currPos = environment.getPosition(navigatingNode)
+                val currPos = environment.getCurrentPosition(navigatingNode)
                 val (closestDest, distanceToClosestDest) = destinations.asSequence()
                     .map { it to it.distanceTo(currPos) }
                     .minBy { it.second }
@@ -86,7 +86,7 @@ open class ReachKnownDestination<T, L : Euclidean2DConvexShape, R>(
      */
     private fun findKnownPathTo(destination: Euclidean2DPosition): List<L> = with(orientingCapability.cognitiveMap) {
         emptyList<L>().takeIf { vertexSet().isEmpty() } ?: let {
-            val currPos = environment.getPosition(node)
+            val currPos = environment.getCurrentPosition(node)
             val currRoom = environment.graph.nodeContaining(currPos)
             val destRoom = environment.graph.nodeContaining(destination)
             if (currRoom == null || destRoom == null) {

From eebb7a74d0b6af4e8e0556b559444ee86223661d Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Sun, 15 Feb 2026 17:26:44 +0100
Subject: [PATCH 21/29] test(engine): simplify engine test suite (fixed detekt
 error)

---
 .../core/{AbstractEngineTest.kt => EngineTest.kt}    |  7 ++-----
 .../unibo/alchemist/core/TestEngineImplementation.kt | 12 ------------
 2 files changed, 2 insertions(+), 17 deletions(-)
 rename alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/{AbstractEngineTest.kt => EngineTest.kt} (92%)
 delete mode 100644 alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineImplementation.kt

diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/AbstractEngineTest.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/EngineTest.kt
similarity index 92%
rename from alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/AbstractEngineTest.kt
rename to alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/EngineTest.kt
index c7dbe7cbf5..71de50bd6f 100644
--- a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/AbstractEngineTest.kt
+++ b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/EngineTest.kt
@@ -12,7 +12,6 @@ package it.unibo.alchemist.core
 import io.kotest.core.spec.style.FreeSpec
 import io.kotest.matchers.shouldBe
 import it.unibo.alchemist.core.util.DependencyUtils
-import it.unibo.alchemist.model.Environment
 import it.unibo.alchemist.model.biochemistry.BiochemistryIncarnation
 import it.unibo.alchemist.model.biochemistry.molecules.Biomolecule
 import it.unibo.alchemist.model.conditions.NeighborHasConcentration
@@ -23,9 +22,7 @@ import it.unibo.alchemist.model.timedistributions.DiracComb
 import it.unibo.alchemist.model.times.DoubleTime
 
 @Suppress("UnnecessaryAbstractClass")
-abstract class AbstractEngineTest(
-    val engineFactory: (Environment<Double, *>) -> Simulation<Double, *>,
-) : FreeSpec({
+class EngineTest : FreeSpec({
 
     "Neighbor Condition: Reaction executes when neighbor has concentration" {
         val incarnation = BiochemistryIncarnation()
@@ -58,7 +55,7 @@ abstract class AbstractEngineTest(
 
         environment.addTerminator { it.simulation.time > DoubleTime(5.0) }
 
-        val engine = engineFactory(environment)
+        val engine = Engine(environment)
         engine.play()
         engine.run()
 
diff --git a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineImplementation.kt b/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineImplementation.kt
deleted file mode 100644
index 052383abfe..0000000000
--- a/alchemist-engine/src/test/kotlin/it/unibo/alchemist/core/TestEngineImplementation.kt
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * Copyright (C) 2010-2026, Danilo Pianini and contributors
- * listed, for each module, in the respective subproject's build.gradle.kts file.
- *
- * This file is part of Alchemist, and is distributed under the terms of the
- * GNU General Public License, with a linking exception,
- * as described in the file LICENSE in the Alchemist distribution's top directory.
- */
-
-package it.unibo.alchemist.core
-
-class TestEngineImplementation : AbstractEngineTest({ env -> Engine(env) })

From 9006e78b1fd6c780251f355fd25b2135c6143fee Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Sun, 15 Feb 2026 18:48:19 +0100
Subject: [PATCH 22/29] chore(implementation-base): suppress
 `AbstractClassCanBeConcreteClass` detekt error

---
 .../conditions/AbstractNonPropensityContributingCondition.kt     | 1 +
 1 file changed, 1 insertion(+)

diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/AbstractNonPropensityContributingCondition.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/AbstractNonPropensityContributingCondition.kt
index 8f27e6fd92..92b27ed375 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/AbstractNonPropensityContributingCondition.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/conditions/AbstractNonPropensityContributingCondition.kt
@@ -16,6 +16,7 @@ import it.unibo.alchemist.model.Node
  * it contributes respectively with 1.0 in case it can execute,
  * or with 0.0 in case it cannot.
  */
+@Suppress("AbstractClassCanBeConcreteClass")
 abstract class AbstractNonPropensityContributingCondition<T>(node: Node<T>) : AbstractCondition<T>(node) {
     init {
         setPropensity(observeValidity().map { if (it) 1.0 else 0.0 })

From b4e7e9021d2a6056c1e41a226f2b0a78044fe6a3 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Mon, 16 Feb 2026 09:45:11 +0100
Subject: [PATCH 23/29] fix(test): retrieve current position from observable
 when asserting

---
 .../src/main/kotlin/it/unibo/alchemist/test/Assertions.kt     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/Assertions.kt b/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/Assertions.kt
index 1d4596127e..56e3246c79 100644
--- a/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/Assertions.kt
+++ b/alchemist-test/src/main/kotlin/it/unibo/alchemist/test/Assertions.kt
@@ -94,8 +94,8 @@ infix fun <T, P : Position<P>> Environment<T, P>.shouldEqual(other: Environment<
     assertEquals(other.isTerminated, isTerminated)
     assertContentEquals(other.sizeInDistanceUnits, sizeInDistanceUnits)
     linkingRule shouldEqual other.linkingRule
-    val positions = nodes.sortedBy { it.id }.map { getPosition(it) }
-    val otherPositions = other.sortedBy { it.id }.map { getPosition(it) }
+    val positions = nodes.sortedBy { it.id }.map { getCurrentPosition(it) }
+    val otherPositions = other.sortedBy { it.id }.map { getCurrentPosition(it) }
     positions.ebeEquals(otherPositions) { expected, actual -> assertEquals(expected, actual) }
     nodes.ebeEquals(other.nodes) { expected, actual ->
         actual shouldEqual expected

From 04c19301a070df5219ebe9bc0709aa31870bfcd0 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 19 Feb 2026 12:25:39 +0100
Subject: [PATCH 24/29] fix(sapere): trigger LSAReaction update only on target
 molecule changes instead of entire LSASpace

---
 .../model/sapere/conditions/LsaNeighborhoodCondition.java | 8 ++++----
 .../model/sapere/conditions/LsaStandardCondition.java     | 3 +--
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
index 843af6d080..8c1ec60664 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
@@ -52,9 +52,9 @@ public LsaNeighborhoodCondition(
         super(molecule, node);
         this.environment = environment;
 
-        // We depend on every neighbor's LSA space, hence an update is triggered
-        // every time a change in node's neighborhood is emitted, or one of the
-        // members' LSA space has changed.
+        // We depend on every neighbor's concentration of the target molecule.
+        // An update is triggered only when a molecule matching the template
+        // is added or removed in any neighbor.
         addObservableDependency(ObservableExtensions.INSTANCE.switchMap(
             environment.getNeighborhood(node).map(Neighborhood::getNeighbors),
             neighbors ->
@@ -62,7 +62,7 @@ public LsaNeighborhoodCondition(
                     neighbors.stream()
                         .filter(it -> it instanceof ILsaNode)
                         .map(neighbor ->
-                            ((ILsaNode) neighbor).observeLsaSpace()
+                            ((ILsaNode) neighbor).observeConcentration(molecule)
                         ).toList(),
                     space -> space
                 )
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
index 5e12001aa6..8d1a24c574 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
@@ -49,8 +49,7 @@ public class LsaStandardCondition extends AbstractLsaCondition {
     public LsaStandardCondition(final ILsaMolecule mol, final ILsaNode n) {
         super(n, Sets.newHashSet(new ILsaMolecule[] {mol}));
 
-        // we trigger the update on any change in the LSA space. Is this correct?
-        addObservableDependency(n.observeLsaSpace());
+        addObservableDependency(n.observeConcentration(mol));
         setValidity(valid);
         setPropensity(MutableObservable.Companion.observe(-1d));
 

From f1cb76e9b85d05885f9e4cd1dfde1e93491c9087 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 19 Feb 2026 12:28:07 +0100
Subject: [PATCH 25/29] fix(implementation-base): merge conditions into single
 observable source

---
 .../model/reactions/AbstractReaction.java     | 31 +++++++++++--------
 1 file changed, 18 insertions(+), 13 deletions(-)

diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
index c89a89b9ad..c918ecfbef 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
@@ -24,14 +24,15 @@
 import it.unibo.alchemist.model.TimeDistribution;
 import it.unibo.alchemist.model.observation.Disposable;
 import it.unibo.alchemist.model.observation.EventObservable;
+import it.unibo.alchemist.model.observation.MutableObservable;
+import it.unibo.alchemist.model.observation.Observable;
+import it.unibo.alchemist.model.observation.ObservableExtensions;
+import it.unibo.alchemist.model.observation.ObservableMutableSet;
 import it.unibo.alchemist.model.observation.lifecycle.Lifecycle;
 import it.unibo.alchemist.model.observation.lifecycle.LifecycleOwner;
 import it.unibo.alchemist.model.observation.lifecycle.LifecycleOwnerKt;
 import it.unibo.alchemist.model.observation.lifecycle.LifecycleRegistry;
 import it.unibo.alchemist.model.observation.lifecycle.LifecycleState;
-import it.unibo.alchemist.model.observation.MutableObservable;
-import it.unibo.alchemist.model.observation.Observable;
-import it.unibo.alchemist.model.observation.ObservableExtensions;
 import kotlin.Unit;
 import org.danilopianini.util.ArrayListSet;
 import org.danilopianini.util.Hashes;
@@ -49,6 +50,7 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static arrow.core.OptionKt.getOrElse;
@@ -362,15 +364,18 @@ protected final void initializeObservableConditions() {
         subscriptions.clear();
         validity.dispose();
 
-        conditions.forEach(condition -> {
-            final var merged = ObservableExtensions.ObservableSetExtensions.mergeObservables(
-                condition.observeInboundDependencies()
-            );
-            subscriptions.add(LifecycleOwnerKt.bindTo(merged, this, it -> {
-                rescheduleRequest.emit();
-                return Unit.INSTANCE;
-            }));
-        });
+        final var allDependencies = conditions.stream()
+            .flatMap(it -> it.observeInboundDependencies().toSet().stream())
+            .collect(Collectors.toSet());
+
+        final Observable<?> merged = ObservableExtensions.ObservableSetExtensions.mergeObservables(
+            ObservableMutableSet.Companion.toObservableSet(allDependencies)
+        );
+
+        subscriptions.add(LifecycleOwnerKt.bindTo(merged, this, it -> {
+            rescheduleRequest.emit();
+            return Unit.INSTANCE;
+        }));
 
         if (!conditions.isEmpty()) {
             validity = ObservableExtensions.INSTANCE.combineLatest(
@@ -406,7 +411,7 @@ protected final void setOutputContext(final Context c) {
 
     /**
      * @return the default implementation returns a String in the form
-     *         className@timeScheduled[Conditions]-rate-&gt;[Actions]
+     * className@timeScheduled[Conditions]-rate-&gt;[Actions]
      */
     @Override
     public String toString() {

From 0e3490a300cc729254bb76e0c3b295be5d3fee63 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 19 Feb 2026 12:49:37 +0100
Subject: [PATCH 26/29] fix(sapere): use generalised molecules for dsl
 expressions test failure

---
 .../model/sapere/conditions/LsaNeighborhoodCondition.java     | 4 ++--
 .../model/sapere/conditions/LsaStandardCondition.java         | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
index 8c1ec60664..d2178cefff 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
@@ -53,7 +53,7 @@ public LsaNeighborhoodCondition(
         this.environment = environment;
 
         // We depend on every neighbor's concentration of the target molecule.
-        // An update is triggered only when a molecule matching the template
+        // An update is triggered only when a molecule matching the generalized template
         // is added or removed in any neighbor.
         addObservableDependency(ObservableExtensions.INSTANCE.switchMap(
             environment.getNeighborhood(node).map(Neighborhood::getNeighbors),
@@ -62,7 +62,7 @@ public LsaNeighborhoodCondition(
                     neighbors.stream()
                         .filter(it -> it instanceof ILsaNode)
                         .map(neighbor ->
-                            ((ILsaNode) neighbor).observeConcentration(molecule)
+                            neighbor.observeConcentration(molecule.generalize())
                         ).toList(),
                     space -> space
                 )
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
index 8d1a24c574..f2d7ab8f1e 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
@@ -49,7 +49,7 @@ public class LsaStandardCondition extends AbstractLsaCondition {
     public LsaStandardCondition(final ILsaMolecule mol, final ILsaNode n) {
         super(n, Sets.newHashSet(new ILsaMolecule[] {mol}));
 
-        addObservableDependency(n.observeConcentration(mol));
+        addObservableDependency(n.observeConcentration(mol.generalize()));
         setValidity(valid);
         setPropensity(MutableObservable.Companion.observe(-1d));
 

From 72584f5927ff30dfb75eaa049b7adbf4bd45dca9 Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 19 Feb 2026 15:28:56 +0100
Subject: [PATCH 27/29] fix(sapere): keep observing for neighbrhoods LSA spaces
 changes

---
 .../sapere/conditions/LsaNeighborhoodCondition.java    | 10 ++++------
 .../model/sapere/conditions/LsaStandardCondition.java  |  2 +-
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
index d2178cefff..a7e8d819a6 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
@@ -52,18 +52,16 @@ public LsaNeighborhoodCondition(
         super(molecule, node);
         this.environment = environment;
 
-        // We depend on every neighbor's concentration of the target molecule.
-        // An update is triggered only when a molecule matching the generalized template
-        // is added or removed in any neighbor.
+        // We depend on every neighbor's LsaSpace.
+        // An update is triggered whenever a neighbor's LSA space changes.
         addObservableDependency(ObservableExtensions.INSTANCE.switchMap(
             environment.getNeighborhood(node).map(Neighborhood::getNeighbors),
             neighbors ->
                 ObservableExtensions.INSTANCE.combineLatest(
                     neighbors.stream()
                         .filter(it -> it instanceof ILsaNode)
-                        .map(neighbor ->
-                            neighbor.observeConcentration(molecule.generalize())
-                        ).toList(),
+                        .map(neighbor -> ((ILsaNode) neighbor).observeLsaSpace())
+                        .toList(),
                     space -> space
                 )
         ));
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
index f2d7ab8f1e..9d4e3796c1 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
@@ -49,7 +49,7 @@ public class LsaStandardCondition extends AbstractLsaCondition {
     public LsaStandardCondition(final ILsaMolecule mol, final ILsaNode n) {
         super(n, Sets.newHashSet(new ILsaMolecule[] {mol}));
 
-        addObservableDependency(n.observeConcentration(mol.generalize()));
+        addObservableDependency(n.observeLsaSpace());
         setValidity(valid);
         setPropensity(MutableObservable.Companion.observe(-1d));
 

From f0bc2f578e28d60042bc2d21b2bbc2f0f140d15f Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Thu, 19 Feb 2026 18:29:22 +0100
Subject: [PATCH 28/29] fix: fix checkstyle error

---
 .../it/unibo/alchemist/model/reactions/AbstractReaction.java    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
index c918ecfbef..56967bbde6 100644
--- a/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
+++ b/alchemist-implementationbase/src/main/java/it/unibo/alchemist/model/reactions/AbstractReaction.java
@@ -411,7 +411,7 @@ protected final void setOutputContext(final Context c) {
 
     /**
      * @return the default implementation returns a String in the form
-     * className@timeScheduled[Conditions]-rate-&gt;[Actions]
+     *      className@timeScheduled[Conditions]-rate-&gt;[Actions]
      */
     @Override
     public String toString() {

From af2a3acc0b507918bc40f6e52673860e3cdd262c Mon Sep 17 00:00:00 2001
From: S-furi <stefano.furi7@gmail.com>
Date: Fri, 20 Feb 2026 14:11:23 +0100
Subject: [PATCH 29/29] perf: improve speed, SAPERE fine-grained dependencies
 and memory usage

commit cbc430612a9a9063264da4f229fec1f7dc270ecd
Author: S-furi <stefano.furi7@gmail.com>
Date:   Fri Feb 20 14:02:00 2026 +0100

    perf(api): make use of persistent collections in observable collections

    this led to a great improvement in memory usage especially for neighbor-related streams where set of nodes where occupying large chunks of memory.

    This usage of persistent structures improved equality checks speed with an overall time reduction of approx a 10% wrt standard kotlin collections usage (from 22s independent test (SAPERE) to 20s)

commit ef9301aed3555d7d97c262a755085ace39bc9c24
Author: S-furi <stefano.furi7@gmail.com>
Date:   Fri Feb 20 11:53:17 2026 +0100

    perf(engine): introduce `BatchManager` to avoid redundant reschedule requests

commit 6c04f40fcea4ce9f644cf2b9e162b999199d524e
Author: S-furi <stefano.furi7@gmail.com>
Date:   Fri Feb 20 11:18:14 2026 +0100

    perf(sapere): introduce finer-grained observables for lsa spaces
---
 alchemist-api/build.gradle.kts                |   1 +
 .../model/observation/ObservableList.kt       |  44 +++----
 .../model/observation/ObservableMap.kt        |  50 +++++---
 .../model/observation/ObservableSet.kt        |  31 ++---
 .../model/observation/ObservableListTest.kt   |   2 +-
 .../kotlin/it/unibo/alchemist/core/Engine.kt  |  19 +++-
 .../alchemist/core/batch/BatchManager.kt      |  62 ++++++++++
 .../alchemist/model/nodes/GenericNode.kt      |   3 +-
 .../alchemist/model/sapere/ILsaNode.java      |   7 ++
 .../conditions/LsaNeighborhoodCondition.java  |   8 +-
 .../conditions/LsaStandardCondition.java      |   2 +-
 .../alchemist/model/sapere/nodes/LsaNode.java | 107 +++++++++++++-----
 gradle/libs.versions.toml                     |   2 +
 13 files changed, 239 insertions(+), 99 deletions(-)
 create mode 100644 alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/batch/BatchManager.kt

diff --git a/alchemist-api/build.gradle.kts b/alchemist-api/build.gradle.kts
index ee1c7a35e2..d86dfbd52e 100644
--- a/alchemist-api/build.gradle.kts
+++ b/alchemist-api/build.gradle.kts
@@ -17,6 +17,7 @@ dependencies {
     api(libs.listset)
     implementation(libs.kotlin.reflect)
     api(libs.arrow.core)
+    api(libs.kotlinx.collections.immutable)
     testImplementation(libs.kotlin.test)
 }
 
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt
index 50d9b26d3a..6bb4006221 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableList.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2025, Danilo Pianini and contributors
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
  * listed, for each module, in the respective subproject's build.gradle.kts file.
  *
  * This file is part of Alchemist, and is distributed under the terms of the
@@ -9,7 +9,9 @@
 
 package it.unibo.alchemist.model.observation
 
-import java.util.Collections
+import kotlinx.collections.immutable.PersistentList
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toPersistentList
 
 /**
  * Represents a list that allows observation of its contents and provides notifications on changes.
@@ -85,12 +87,12 @@ interface ObservableList<T> : Observable<List<T>> {
  */
 class ObservableMutableList<T> : ObservableList<T> {
 
-    private val backing: MutableList<T> = ArrayList()
+    private var backing: PersistentList<T> = persistentListOf()
     private val sizeObservable = MutableObservable.observe(0)
 
     override val observableSize: Observable<Int> = sizeObservable
 
-    override val current: List<T> get() = Collections.unmodifiableList(backing)
+    override val current: List<T> get() = backing
 
     override val observers: List<Any> get() = observingCallbacks.keys.toList()
 
@@ -104,9 +106,9 @@ class ObservableMutableList<T> : ObservableList<T> {
      * @return `true` (as specified by [MutableList.add])
      */
     fun add(item: T): Boolean {
-        val result = backing.add(item)
+        backing = backing.add(item)
         notifyObservers()
-        return result
+        return true
     }
 
     /**
@@ -117,7 +119,7 @@ class ObservableMutableList<T> : ObservableList<T> {
      * @param item The item to be added to the list.
      */
     fun add(index: Int, item: T) {
-        backing.add(index, item)
+        backing = backing.add(index, item)
         notifyObservers()
     }
 
@@ -128,9 +130,9 @@ class ObservableMutableList<T> : ObservableList<T> {
      * @return `true` if this list changed as a result of the call
      */
     fun addAll(items: Collection<T>): Boolean = if (items.isNotEmpty()) {
-        val result = backing.addAll(items)
+        backing = backing.addAll(items)
         notifyObservers()
-        result
+        true
     } else {
         false
     }
@@ -143,8 +145,10 @@ class ObservableMutableList<T> : ObservableList<T> {
      * @return `true` if the list contained the specified element
      */
     fun remove(item: T): Boolean {
-        val result = backing.remove(item)
+        val newBacking = backing.remove(item)
+        val result = newBacking !== backing
         if (result) {
+            backing = newBacking
             notifyObservers()
         }
         return result
@@ -157,9 +161,10 @@ class ObservableMutableList<T> : ObservableList<T> {
      * @return the element that was removed from the list
      */
     fun removeAt(index: Int): T {
-        val result = backing.removeAt(index)
+        val old = backing[index]
+        backing = backing.removeAt(index)
         notifyObservers()
-        return result
+        return old
     }
 
     /**
@@ -170,8 +175,9 @@ class ObservableMutableList<T> : ObservableList<T> {
      * @return the element previously at the specified position
      */
     operator fun set(index: Int, element: T): T {
-        val old = backing.set(index, element)
+        val old = backing[index]
         if (old != element) {
+            backing = backing.set(index, element)
             notifyObservers()
         }
         return old
@@ -182,7 +188,7 @@ class ObservableMutableList<T> : ObservableList<T> {
      */
     fun clear() {
         if (backing.isNotEmpty()) {
-            backing.clear()
+            backing = persistentListOf()
             notifyObservers()
         }
     }
@@ -199,15 +205,15 @@ class ObservableMutableList<T> : ObservableList<T> {
     override fun dispose() {
         observingCallbacks.clear()
         sizeObservable.dispose()
-        backing.clear()
+        backing = persistentListOf()
     }
 
     override operator fun get(index: Int): T = backing[index]
 
-    override fun toList(): List<T> = Collections.unmodifiableList(ArrayList(backing))
+    override fun toList(): List<T> = backing
 
     override fun copy(): ObservableMutableList<T> = ObservableMutableList<T>().apply {
-        this@ObservableMutableList.backing.forEach(this::add)
+        backing = this@ObservableMutableList.backing
     }
 
     override operator fun contains(item: T): Boolean = backing.contains(item)
@@ -233,7 +239,7 @@ class ObservableMutableList<T> : ObservableList<T> {
 
     private fun notifyObservers() {
         sizeObservable.update { backing.size }
-        val snapshot = toList()
+        val snapshot = backing
         observingCallbacks.values.forEach { callbacks ->
             callbacks.forEach { it(snapshot) }
         }
@@ -262,7 +268,7 @@ class ObservableMutableList<T> : ObservableList<T> {
          * @return A new [ObservableMutableList] containing the specified items.
          */
         operator fun <T> invoke(vararg items: T): ObservableMutableList<T> = ObservableMutableList<T>().apply {
-            items.forEach(this::add)
+            backing = items.toList().toPersistentList()
         }
     }
 }
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
index 736581ce9e..073b0128cc 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableMap.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2025, Danilo Pianini and contributors
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
  * listed, for each module, in the respective subproject's build.gradle.kts file.
  *
  * This file is part of Alchemist, and is distributed under the terms of the
@@ -14,7 +14,10 @@ import arrow.core.none
 import arrow.core.some
 import it.unibo.alchemist.model.observation.MutableObservable.Companion.observe
 import it.unibo.alchemist.model.observation.Observable.ObservableExtensions.currentOrNull
-import java.util.Collections
+import kotlinx.collections.immutable.PersistentMap
+import kotlinx.collections.immutable.mutate
+import kotlinx.collections.immutable.persistentMapOf
+import kotlinx.collections.immutable.toPersistentMap
 
 /**
  * Represents an observable map that allows observation of changes to its contents,
@@ -91,12 +94,13 @@ interface ObservableMap<K, V> : Observable<Map<K, V>> {
  * @param V The type of mapped values.
  * @property backingMap The internal mutable map that stores the key-value pairs.
  */
-open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> = linkedMapOf()) : ObservableMap<K, V> {
+open class ObservableMutableMap<K, V>(initial: Map<K, V> = emptyMap()) : ObservableMap<K, V> {
 
+    private var backingMap: PersistentMap<K, V> = initial.toPersistentMap()
     private val keyObservables: MutableMap<K, MutableObservable<Option<V>>> = linkedMapOf()
     override val observingCallbacks: MutableMap<Any, List<(Map<K, V>) -> Unit>> = linkedMapOf()
 
-    override val current: Map<K, V> = Collections.unmodifiableMap(backingMap)
+    override val current: Map<K, V> get() = backingMap
 
     override val observers: List<Any> get() = observingCallbacks.keys.toList()
 
@@ -116,8 +120,9 @@ open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> =
      * @param value The value associated with the specified key.
      */
     fun put(key: K, value: V) {
-        val previous: V? = backingMap.put(key, value)
+        val previous = backingMap[key]
         if (previous != value) {
+            backingMap = backingMap.put(key, value)
             getAsMutable(key).update { value.some() }
             notifyMapObservers()
         }
@@ -130,9 +135,14 @@ open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> =
      * @param key The key whose mapping is to be removed from the map.
      * @return the previous value associated with the key, or null if the key was not present in the map.
      */
-    fun remove(key: K): V? = backingMap.remove(key).also {
-        val previousObservedValue = keyObservables[key]?.update { none() } ?: none()
-        if (previousObservedValue.isSome()) notifyMapObservers()
+    fun remove(key: K): V? {
+        val previous = backingMap[key]
+        if (previous != null || key in backingMap) {
+            backingMap = backingMap.remove(key)
+            keyObservables[key]?.update { none() }
+            notifyMapObservers()
+        }
+        return previous
     }
 
     /**
@@ -144,10 +154,10 @@ open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> =
      */
     fun clearAndPutAll(from: Map<K, V>) {
         var changed = false
-        val keysToRemove = backingMap.keys.toSet() - from.keys
+        val keysToRemove = backingMap.keys - from.keys
         if (keysToRemove.isNotEmpty()) {
+            backingMap = backingMap.mutate { it -= keysToRemove }
             keysToRemove.forEach { key ->
-                backingMap.remove(key)
                 keyObservables[key]?.update { none() }
             }
             changed = true
@@ -155,8 +165,9 @@ open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> =
 
         if (from.isNotEmpty()) {
             from.forEach { (key, value) ->
-                val previous = backingMap.put(key, value)
+                val previous = backingMap[key]
                 if (previous != value) {
+                    backingMap = backingMap.put(key, value)
                     getAsMutable(key).update { value.some() }
                     changed = true
                 }
@@ -170,7 +181,7 @@ open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> =
 
     override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (Map<K, V>) -> Unit) {
         observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
-        if (invokeOnRegistration) callback(current.toMap())
+        if (invokeOnRegistration) callback(backingMap)
     }
 
     override fun stopWatching(registrant: Any) {
@@ -189,9 +200,9 @@ open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> =
     override fun dispose() {
         keyObservables.values.forEach { it.dispose() }
         keyObservables.clear()
-        observingCallbacks.keys.forEach(::stopWatching)
+        observingCallbacks.keys.toList().forEach(::stopWatching)
         observingCallbacks.clear()
-        backingMap.clear()
+        backingMap = persistentMapOf()
     }
 
     override fun isEmpty(): Boolean = backingMap.isEmpty()
@@ -201,9 +212,9 @@ open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> =
      *
      * @return A new instance of ObservableMutableMap containing the same key-value pairs as the original.
      */
-    fun copy(): ObservableMutableMap<K, V> = ObservableMutableMap(backingMap.toMutableMap())
+    fun copy(): ObservableMutableMap<K, V> = ObservableMutableMap(backingMap)
 
-    override fun asMap(): Map<K, V> = Collections.unmodifiableMap(backingMap)
+    override fun asMap(): Map<K, V> = backingMap
 
     override operator fun get(key: K): Observable<Option<V>> = getAsMutable(key)
 
@@ -224,8 +235,11 @@ open class ObservableMutableMap<K, V>(private val backingMap: MutableMap<K, V> =
      */
     operator fun minus(key: K) = remove(key)
 
-    private fun notifyMapObservers() = observingCallbacks.values.forEach { callbacks ->
-        callbacks.forEach { it(current.toMap()) }
+    private fun notifyMapObservers() {
+        val snapshot = backingMap
+        observingCallbacks.values.forEach { callbacks ->
+            callbacks.forEach { it(snapshot) }
+        }
     }
 
     private fun getAsMutable(key: K): MutableObservable<Option<V>> = keyObservables.getOrPut(key) { observe(none()) }
diff --git a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt
index a7472091f9..09996e28a8 100644
--- a/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt
+++ b/alchemist-api/src/main/kotlin/it/unibo/alchemist/model/observation/ObservableSet.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2025, Danilo Pianini and contributors
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
  * listed, for each module, in the respective subproject's build.gradle.kts file.
  *
  * This file is part of Alchemist, and is distributed under the terms of the
@@ -9,9 +9,6 @@
 
 package it.unibo.alchemist.model.observation
 
-import arrow.core.getOrElse
-import java.util.Collections
-
 /**
  * Represents a set that allows observation of its contents and provides notifications on changes.
  * This interface supports observing the entire set, individual item membership, and various utility operations.
@@ -85,9 +82,9 @@ interface ObservableSet<T> : Observable<Set<T>> {
  *
  * @param T The type of elements maintained by this set.
  */
-class ObservableMutableSet<T> : ObservableSet<T> {
+class ObservableMutableSet<T>(initial: Iterable<T> = emptyList()) : ObservableSet<T> {
 
-    private val backing = ObservableMutableMap<T, Boolean>()
+    private val backing = ObservableMutableMap<T, Boolean>(initial.associateWith { true })
 
     override val observableSize: Observable<Int> = backing.map { it.keys.size }
 
@@ -138,7 +135,7 @@ class ObservableMutableSet<T> : ObservableSet<T> {
 
     override fun onChange(registrant: Any, invokeOnRegistration: Boolean, callback: (Set<T>) -> Unit) {
         observingCallbacks[registrant] = observingCallbacks[registrant].orEmpty() + callback
-        backing.onChange(this to registrant, invokeOnRegistration) { callback(it.keys.toSet()) }
+        backing.onChange(this to registrant, invokeOnRegistration) { callback(it.keys) }
     }
 
     override fun stopWatching(registrant: Any) {
@@ -152,15 +149,13 @@ class ObservableMutableSet<T> : ObservableSet<T> {
         observingCallbacks.clear()
     }
 
-    override fun observeMembership(item: T): Observable<Boolean> = backing[item].map { opt -> opt.getOrElse { false } }
+    override fun observeMembership(item: T): Observable<Boolean> = backing[item].map { opt -> opt.isSome() }
 
-    override fun toSet(): Set<T> = Collections.unmodifiableSet(backing.current.keys)
+    override fun toSet(): Set<T> = backing.current.keys
 
     override fun toList(): List<T> = backing.current.keys.toList()
 
-    override fun copy(): ObservableMutableSet<T> = ObservableMutableSet<T>().apply {
-        this@ObservableMutableSet.backing.asMap().keys.forEach(this::add)
-    }
+    override fun copy(): ObservableMutableSet<T> = ObservableMutableSet(backing.asMap().keys)
 
     override operator fun contains(item: T): Boolean = item in backing.current
 
@@ -194,9 +189,7 @@ class ObservableMutableSet<T> : ObservableSet<T> {
          *
          * @return An instance of `ObservableMutableSet` containing all unique elements from the original list.
          */
-        fun <T> List<T>.toObservableSet(): ObservableMutableSet<T> = ObservableMutableSet<T>().also {
-            this.forEach(it::add)
-        }
+        fun <T> List<T>.toObservableSet(): ObservableMutableSet<T> = ObservableMutableSet<T>(this)
 
         /**
          * Converts the current set into an observable mutable set.
@@ -204,9 +197,7 @@ class ObservableMutableSet<T> : ObservableSet<T> {
          *
          * @return An instance of `ObservableMutableSet` containing all the elements from the original set.
          */
-        fun <T> Set<T>.toObservableSet(): ObservableMutableSet<T> = ObservableMutableSet<T>().also {
-            this.forEach(it::add)
-        }
+        fun <T> Set<T>.toObservableSet(): ObservableMutableSet<T> = ObservableMutableSet<T>(this)
 
         /**
          * Creates a new [ObservableMutableSet] and populates it with the specified items.
@@ -215,8 +206,6 @@ class ObservableMutableSet<T> : ObservableSet<T> {
          * The items are provided as a variable number of arguments.
          * @return A new [ObservableMutableSet] containing the specified items.
          */
-        operator fun <T> invoke(vararg items: T): ObservableMutableSet<T> = ObservableMutableSet<T>().apply {
-            items.forEach(this::add)
-        }
+        operator fun <T> invoke(vararg items: T): ObservableMutableSet<T> = ObservableMutableSet<T>(items.toList())
     }
 }
diff --git a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableListTest.kt b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableListTest.kt
index 525487173a..66445f3c3e 100644
--- a/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableListTest.kt
+++ b/alchemist-api/src/test/kotlin/it/unibo/alchemist/model/observation/ObservableListTest.kt
@@ -90,7 +90,7 @@ class ObservableListTest : FunSpec({
             val list = ObservableMutableList(1, 2, 3)
             var nextExpected = 3
 
-            list.observableSize.onChange(this) { it shouldBe nextExpected }
+            list.observableSize.onChange(this, false) { it shouldBe nextExpected }
 
             repeat(3) {
                 nextExpected++
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
index 231fd85a93..917663dbb2 100644
--- a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
+++ b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/Engine.kt
@@ -8,6 +8,7 @@
  */
 package it.unibo.alchemist.core
 
+import it.unibo.alchemist.core.batch.BatchManager
 import it.unibo.alchemist.model.Actionable
 import it.unibo.alchemist.model.Environment
 import it.unibo.alchemist.model.Neighborhood
@@ -28,6 +29,8 @@ open class Engine<T, P : Position<out P>>(
     protected val scheduler: Scheduler<T>,
 ) : AbstractEngine<T, P>(environment) {
 
+    private val batchManager = BatchManager<T>()
+
     constructor(environment: Environment<T, P>) : this(environment, ArrayIndexedPriorityQueue())
 
     override fun initialize() {
@@ -46,12 +49,14 @@ open class Engine<T, P : Position<out P>>(
             "$nextEvent is scheduled in the past at time $scheduledTime. Current time: $time; current step: $step."
         }
         currentTime = scheduledTime
-        if (scheduledTime.isFinite && nextEvent.canExecute()) {
-            nextEvent.conditions.forEach { it.reactionReady() }
-            nextEvent.execute()
+        batchManager.useBatch(onReschedule = { updateReaction(it) }) {
+            if (scheduledTime.isFinite && nextEvent.canExecute()) {
+                nextEvent.conditions.forEach { it.reactionReady() }
+                nextEvent.execute()
+            }
+            nextEvent.update(time, true, environment)
+            scheduler.updateReaction(nextEvent)
         }
-        nextEvent.update(time, true, environment)
-        scheduler.updateReaction(nextEvent)
 
         monitors.forEach { it.stepDone(environment, nextEvent, time, step) }
         if (environment.isTerminated) {
@@ -95,7 +100,9 @@ open class Engine<T, P : Position<out P>>(
         scheduler.addReaction(reaction)
 
         reaction.rescheduleRequest.onChange(this, false) {
-            updateReaction(reaction)
+            batchManager.requestReschedule(reaction) {
+                updateReaction(reaction)
+            }
         }
     }
 
diff --git a/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/batch/BatchManager.kt b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/batch/BatchManager.kt
new file mode 100644
index 0000000000..ba51402b38
--- /dev/null
+++ b/alchemist-engine/src/main/kotlin/it/unibo/alchemist/core/batch/BatchManager.kt
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2010-2026, Danilo Pianini and contributors
+ * listed, for each module, in the respective subproject's build.gradle.kts file.
+ *
+ * This file is part of Alchemist, and is distributed under the terms of the
+ * GNU General Public License, with a linking exception,
+ * as described in the file LICENSE in the Alchemist distribution's top directory.
+ */
+package it.unibo.alchemist.core.batch
+
+import it.unibo.alchemist.model.Actionable
+import java.util.Collections
+import java.util.IdentityHashMap
+
+/**
+ * A manager for batching [Actionable] reschedule requests.
+ * This is used to avoid redundant updates to the scheduler when multiple
+ * dependencies change in a single simulation step.
+ */
+class BatchManager<T> {
+    private val dirtyReactions = Collections.newSetFromMap(IdentityHashMap<Actionable<T>, Boolean>())
+    private var isBatching = false
+
+    /**
+     * Executes the given [block] in a batch context.
+     * Reschedule requests during this block will be collected and processed
+     * only at the end of the block.
+     *
+     * @param onReschedule the callback to invoke for each unique reaction that requested a reschedule
+     * @param block the block of code to execute
+     */
+    fun useBatch(onReschedule: (Actionable<T>) -> Unit, block: () -> Unit) {
+        val wasBatching = isBatching
+        isBatching = true
+        return try {
+            block()
+        } finally {
+            isBatching = wasBatching
+            if (!isBatching) {
+                val toProcess = dirtyReactions.toList()
+                dirtyReactions.clear()
+                toProcess.forEach(onReschedule)
+            }
+        }
+    }
+
+    /**
+     * Records a reschedule request for the given [reaction].
+     * If a batch is active, the request is collected and processed later.
+     * Otherwise, the [otherwise] block is executed immediately.
+     *
+     * @param reaction the reaction that requested a reschedule
+     * @param otherwise the block to execute if no batch is active
+     */
+    fun requestReschedule(reaction: Actionable<T>, otherwise: () -> Unit) {
+        if (isBatching) {
+            dirtyReactions.add(reaction)
+        } else {
+            otherwise()
+        }
+    }
+}
diff --git a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
index 01daa4caf4..223b24abfb 100644
--- a/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
+++ b/alchemist-implementationbase/src/main/kotlin/it/unibo/alchemist/model/nodes/GenericNode.kt
@@ -22,7 +22,6 @@ import it.unibo.alchemist.model.observation.Observable
 import it.unibo.alchemist.model.observation.ObservableMutableMap
 import it.unibo.alchemist.model.observation.lifecycle.LifecycleRegistry
 import it.unibo.alchemist.model.observation.lifecycle.LifecycleState
-import java.util.Collections
 import java.util.Spliterator
 import java.util.concurrent.Semaphore
 import java.util.concurrent.atomic.AtomicInteger
@@ -97,7 +96,7 @@ constructor(
 
     override fun observeConcentration(molecule: Molecule): Observable<Option<T>> = observableContents[molecule]
 
-    override val contents: Map<Molecule, T> = Collections.unmodifiableMap(observableContents.current)
+    override val contents: Map<Molecule, T> get() = observableContents.current
 
     override val moleculeCount: Int get() = observeMoleculeCount.current
 
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/ILsaNode.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/ILsaNode.java
index 67441780a8..4c16bb85ec 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/ILsaNode.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/ILsaNode.java
@@ -11,6 +11,7 @@
 
 import it.unibo.alchemist.model.Molecule;
 import it.unibo.alchemist.model.Node;
+import it.unibo.alchemist.model.observation.Observable;
 import it.unibo.alchemist.model.observation.ObservableList;
 
 import javax.annotation.Nonnull;
@@ -53,4 +54,10 @@ public interface ILsaNode extends Node<List<ILsaMolecule>> {
     @Override
     List<ILsaMolecule> getConcentration(@Nonnull Molecule mol);
 
+    /**
+     * @param name the name of the molecule to observe
+     * @return an observable that emits the list of molecules with the given name
+     */
+    Observable<List<ILsaMolecule>> observeMoleculeName(String name);
+
 }
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
index a7e8d819a6..c68f3ce713 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaNeighborhoodCondition.java
@@ -52,15 +52,17 @@ public LsaNeighborhoodCondition(
         super(molecule, node);
         this.environment = environment;
 
-        // We depend on every neighbor's LsaSpace.
-        // An update is triggered whenever a neighbor's LSA space changes.
+        final String moleculeName = molecule.getArg(0).toString();
+
+        // We depend on every neighbor's LsaSpace for the specific molecule name.
+        // An update is triggered whenever a neighbor's LSA space for that name changes.
         addObservableDependency(ObservableExtensions.INSTANCE.switchMap(
             environment.getNeighborhood(node).map(Neighborhood::getNeighbors),
             neighbors ->
                 ObservableExtensions.INSTANCE.combineLatest(
                     neighbors.stream()
                         .filter(it -> it instanceof ILsaNode)
-                        .map(neighbor -> ((ILsaNode) neighbor).observeLsaSpace())
+                        .map(neighbor -> ((ILsaNode) neighbor).observeMoleculeName(moleculeName))
                         .toList(),
                     space -> space
                 )
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
index 9d4e3796c1..b525dfd845 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/conditions/LsaStandardCondition.java
@@ -49,7 +49,7 @@ public class LsaStandardCondition extends AbstractLsaCondition {
     public LsaStandardCondition(final ILsaMolecule mol, final ILsaNode n) {
         super(n, Sets.newHashSet(new ILsaMolecule[] {mol}));
 
-        addObservableDependency(n.observeLsaSpace());
+        addObservableDependency(n.observeMoleculeName(mol.getArg(0).toString()));
         setValidity(valid);
         setPropensity(MutableObservable.Companion.observe(-1d));
 
diff --git a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/nodes/LsaNode.java b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/nodes/LsaNode.java
index 39e8817f96..9915b3fcc8 100644
--- a/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/nodes/LsaNode.java
+++ b/alchemist-incarnation-sapere/src/main/java/it/unibo/alchemist/model/sapere/nodes/LsaNode.java
@@ -17,6 +17,7 @@
 import it.unibo.alchemist.model.observation.Observable;
 import it.unibo.alchemist.model.observation.ObservableList;
 import it.unibo.alchemist.model.observation.ObservableMutableList;
+import it.unibo.alchemist.model.observation.ObservableMutableMap;
 import it.unibo.alchemist.model.sapere.ILsaMolecule;
 import it.unibo.alchemist.model.sapere.ILsaNode;
 import it.unibo.alchemist.model.sapere.dsl.IExpression;
@@ -44,7 +45,11 @@ public final class LsaNode extends GenericNode<List<ILsaMolecule>> implements IL
     private static final long serialVersionUID = -2167025208984968645L;
     private static final ILsaMolecule ZEROMOL = new LsaMolecule("0");
 
-    private final ObservableMutableList<ILsaMolecule> instances = new ObservableMutableList<>();
+    private final Map<String, List<ILsaMolecule>> instancesByName = new HashMap<>();
+    private final Map<String, MutableObservable<List<ILsaMolecule>>> observablesByName = new HashMap<>();
+    private final MutableObservable<Integer> moleculeCount = MutableObservable.Companion.observe(0);
+    private final ObservableMutableList<ILsaMolecule> allInstances = new ObservableMutableList<>();
+    private boolean contentsDirty = true;
 
     /**
      * @param environment
@@ -52,16 +57,37 @@ public final class LsaNode extends GenericNode<List<ILsaMolecule>> implements IL
      */
     public LsaNode(final Environment<List<ILsaMolecule>, ?> environment) {
         super(environment);
-        this.instances.onChange(this, this::updateContents);
+        this.allInstances.onChange(this, it -> {
+            contentsDirty = true;
+            return Unit.INSTANCE;
+        });
+    }
+
+    @Override
+    @NotNull
+    public Map<Molecule, List<ILsaMolecule>> getContents() {
+        if (contentsDirty) {
+            updateContents(allInstances.toList());
+        }
+        return super.getContents();
+    }
+
+    @Override
+    @NotNull
+    public ObservableMutableMap<Molecule, List<ILsaMolecule>> getObservableContents() {
+        if (contentsDirty) {
+            updateContents(allInstances.toList());
+        }
+        return super.getObservableContents();
     }
 
     @Override
     @NotNull
     public Observable<Boolean> observeContains(@NotNull final Molecule molecule) {
         if (molecule instanceof final ILsaMolecule toMatch) {
-            synchronized (instances) {
-                return instances.map(molecules -> molecules.stream().anyMatch(mol -> mol.matches(toMatch)));
-            }
+            return observeMoleculeName(toMatch.getArg(0).toString()).map(molecules ->
+                molecules.stream().anyMatch(mol -> mol.matches(toMatch))
+            );
         }
         return MutableObservable.Companion.observe(false);
     }
@@ -75,9 +101,7 @@ protected List<ILsaMolecule> createT() { // NOPMD: this must return null, not an
     @Override
     @NotNull
     public Observable<Integer> getObserveMoleculeCount() {
-        synchronized (instances) {
-            return instances.getObservableSize();
-        }
+        return moleculeCount;
     }
 
     @Override
@@ -86,36 +110,54 @@ public Observable<Option<List<ILsaMolecule>>> observeConcentration(@NotNull fina
         if (!(molecule instanceof final ILsaMolecule mol)) {
             throw new IllegalArgumentException(molecule + " is not a compatible molecule type");
         }
-        synchronized (instances) {
-            return instances.map(current -> {
-                final ArrayList<ILsaMolecule> res = new ArrayList<>();
-                for (final ILsaMolecule instance : current) {
-                    if (mol.matches(instance)) {
-                        res.add(instance);
-                    }
+        return observeMoleculeName(mol.getArg(0).toString()).map(current -> {
+            final ArrayList<ILsaMolecule> res = new ArrayList<>();
+            for (final ILsaMolecule instance : current) {
+                if (mol.matches(instance)) {
+                    res.add(instance);
                 }
-                return Option.fromNullable(res);
-            });
+            }
+            return Option.fromNullable(res);
+        });
+    }
+
+    @Override
+    @NotNull
+    public Observable<List<ILsaMolecule>> observeMoleculeName(@NotNull final String name) {
+        synchronized (instancesByName) {
+            return observablesByName.computeIfAbsent(name, k ->
+                MutableObservable.Companion.observe(instancesByName.getOrDefault(name, Collections.emptyList()))
+            );
         }
     }
 
     @Override
     public List<ILsaMolecule> getLsaSpace() {
-        return Collections.unmodifiableList(observeLsaSpace().toList());
+        return Collections.unmodifiableList(allInstances.toList());
     }
 
     @Override
     public ObservableList<ILsaMolecule> observeLsaSpace() {
-        return instances;
+        return allInstances;
     }
 
     @Override
     public boolean removeConcentration(final ILsaMolecule matchedInstance) {
-        synchronized (instances) {
-            for (int i = 0; i < instances.getObservableSize().getCurrent(); i++) {
-                if (matchedInstance.matches(instances.get(i))) {
-                    instances.removeAt(i);
-                    return true;
+        synchronized (instancesByName) {
+            final String name = matchedInstance.getArg(0).toString();
+            final List<ILsaMolecule> list = instancesByName.get(name);
+            if (list != null) {
+                for (int i = 0; i < list.size(); i++) {
+                    if (matchedInstance.matches(list.get(i))) {
+                        list.remove(i);
+                        moleculeCount.update(c -> c - 1);
+                        allInstances.remove(matchedInstance);
+                        final var obs = observablesByName.get(name);
+                        if (obs != null) {
+                            obs.update(it -> new ArrayList<>(list));
+                        }
+                        return true;
+                    }
                 }
             }
         }
@@ -125,8 +167,16 @@ public boolean removeConcentration(final ILsaMolecule matchedInstance) {
     @Override
     public void setConcentration(final ILsaMolecule inst) {
         if (inst.isIstance()) {
-            synchronized (instances) {
-                instances.add(inst);
+            synchronized (instancesByName) {
+                final String name = inst.getArg(0).toString();
+                final List<ILsaMolecule> list = instancesByName.computeIfAbsent(name, k -> new ArrayList<>());
+                list.add(inst);
+                moleculeCount.update(c -> c + 1);
+                allInstances.add(inst);
+                final var obs = observablesByName.get(name);
+                if (obs != null) {
+                    obs.update(it -> new ArrayList<>(list));
+                }
             }
         } else {
             throw new IllegalStateException("Tried to insert uninstanced " + inst + " into " + this);
@@ -145,7 +195,7 @@ public void setConcentration(@Nonnull final Molecule molecule, final List<ILsaMo
     @Override
     @Nonnull
     public String toString() {
-        return getId() + " contains: " + instances.getCurrent();
+        return getId() + " contains: " + allInstances.getCurrent();
     }
 
     private Unit updateContents(final List<? extends ILsaMolecule> currentInstances) {
@@ -166,7 +216,8 @@ private Unit updateContents(final List<? extends ILsaMolecule> currentInstances)
             final IExpression e = new Expression(new NumTreeNode(v));
             l.set(0, new LsaMolecule(Collections.singletonList(e)));
         }
-        getObservableContents().clearAndPutAll(res);
+        contentsDirty = false;
+        super.getObservableContents().clearAndPutAll(res);
         return null;
     }
 }
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 7fa2627f5a..36eb16661e 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -12,6 +12,7 @@ junit = "6.0.3"
 konf = "1.1.2"
 kotest = "6.1.4"
 kotlin = "2.3.10"
+kotlinx-collections = "0.4.0"
 ksp = "2.3.6"
 kotlinx-coroutines = "1.10.2"
 ktor = "3.4.1"
@@ -94,6 +95,7 @@ kotlin-test-annotations = { module = "org.jetbrains.kotlin:kotlin-test-annotatio
 ksp-api = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "ksp" }
 ksp = { module = "com.google.devtools.ksp:symbol-processing", version.ref = "ksp" }
 kotlinx-atomicfu-runtime = { module = "org.jetbrains.kotlin:kotlinx-atomicfu-runtime", version.ref = "kotlin" }
+kotlinx-collections-immutable = { module = "org.jetbrains.kotlinx:kotlinx-collections-immutable", version.ref = "kotlinx-collections" }
 kotlinx-serialization-json = "org.jetbrains.kotlinx:kotlinx-serialization-json:1.10.0"
 kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
 ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }