diff --git a/examples/posix/federated/receiver.c b/examples/posix/federated/receiver.c
index 8b4c235ee..8d77e022a 100644
--- a/examples/posix/federated/receiver.c
+++ b/examples/posix/federated/receiver.c
@@ -35,7 +35,7 @@ typedef struct {
 LF_DEFINE_REACTION_BODY(Receiver, r) {
   LF_SCOPE_SELF(Receiver);
   LF_SCOPE_ENV();
-  LF_SCOPE_PORT(Receiver, in);
+  LF_SCOPE_PORT_TRIGGER(Receiver, in);
   printf("Input triggered @ %" PRId64 " with %s size %d\n", env->get_elapsed_logical_time(env), in->value.msg,
          in->value.size);
 }
diff --git a/examples/posix/federated/sender.c b/examples/posix/federated/sender.c
index 5a2bcefea..88512f678 100644
--- a/examples/posix/federated/sender.c
+++ b/examples/posix/federated/sender.c
@@ -39,7 +39,7 @@ typedef struct {
 LF_DEFINE_REACTION_BODY(Sender, r) {
   LF_SCOPE_SELF(Sender);
   LF_SCOPE_ENV();
-  LF_SCOPE_PORT(Sender, out);
+  LF_SCOPE_PORT_EFFECT(Sender, out);
 
   printf("Timer triggered @ %" PRId64 "\n", env->get_elapsed_logical_time(env));
   msg_t val;
diff --git a/examples/zephyr/basic_federated/federated_sender/src/sender.c b/examples/zephyr/basic_federated/federated_sender/src/sender.c
index 024dec6cd..cd149eab1 100644
--- a/examples/zephyr/basic_federated/federated_sender/src/sender.c
+++ b/examples/zephyr/basic_federated/federated_sender/src/sender.c
@@ -77,7 +77,7 @@ typedef struct {
 LF_DEFINE_REACTION_BODY(Sender, r) {
   LF_SCOPE_SELF(Sender);
   LF_SCOPE_ENV();
-  LF_SCOPE_PORT(Sender, out);
+  LF_SCOPE_PORT_EFFECT(Sender, out);
   gpio_pin_toggle_dt(&led);
   printf("Reaction triggered @ %" PRId64 " (%" PRId64 "), %" PRId64 ")\n", env->get_elapsed_logical_time(env),
          env->get_logical_time(env), env->get_physical_time(env));
diff --git a/examples/zephyr/hello_lf/CMakeLists.txt b/examples/zephyr/hello_lf/CMakeLists.txt
index 0fba35c14..5d829ebfb 100644
--- a/examples/zephyr/hello_lf/CMakeLists.txt
+++ b/examples/zephyr/hello_lf/CMakeLists.txt
@@ -6,6 +6,6 @@ set(PLATFORM "ZEPHYR" CACHE STRING "Set platform to Zephyr")
 include(src-gen/HelloLF/CMakeLists.txt)
 add_subdirectory(${REACTOR_UC_PATH})
 
-target_sources(app PRIVATE main.c ${LF_SOURCES})
+target_sources(app PRIVATE main.c ${LFC_GEN_SOURCES})
 target_link_libraries(app PRIVATE reactor-uc)
 target_include_directories(app PRIVATE ${LF_INCLUDE_DIRS})
diff --git a/include/reactor-uc/macros.h b/include/reactor-uc/macros.h
index 2ca83b785..bb10448c2 100644
--- a/include/reactor-uc/macros.h
+++ b/include/reactor-uc/macros.h
@@ -397,19 +397,27 @@
   self->_triggers[_triggers_idx++] = (Trigger *)&self->ActionName;                                                     \
   ReactorName##_##ActionName##_ctor(&self->ActionName, &self->super, MinDelay)
 
-#define LF_SCOPE_ACTION(ReactorName, ActionName)                                                                       \
+#define LF_SCOPE_ACTION_TRIGGER(ReactorName, ActionName)                                                               \
+  const ReactorName##_##ActionName *ActionName = &self->ActionName;                                                    \
+  (void)ActionName;
+
+#define LF_SCOPE_ACTION_EFFECT(ReactorName, ActionName)                                                                \
   ReactorName##_##ActionName *ActionName = &self->ActionName;                                                          \
   (void)ActionName;
 
 #define LF_SCOPE_TIMER(ReactorName, TimerName)                                                                         \
-  ReactorName##_##TimerName *TimerName = &self->TimerName;                                                             \
+  const ReactorName##_##TimerName *TimerName = &self->TimerName;                                                       \
   (void)TimerName;
 
-#define LF_SCOPE_PORT(ReactorName, PortName)                                                                           \
+#define LF_SCOPE_PORT_TRIGGER(ReactorName, PortName)                                                                   \
+  const ReactorName##_##PortName *PortName = &self->PortName[0];                                                       \
+  (void)PortName;
+
+#define LF_SCOPE_PORT_EFFECT(ReactorName, PortName)                                                                    \
   ReactorName##_##PortName *PortName = &self->PortName[0];                                                             \
   (void)PortName;
 
-#define LF_SCOPE_MULTIPORT(ReactorName, PortName)                                                                      \
+#define LF_SCOPE_MULTIPORT_EFFECT(ReactorName, PortName)                                                               \
   size_t PortName##_width = sizeof(self->PortName) / sizeof(self->PortName[0]);                                        \
   ReactorName##_##PortName *PortName[PortName##_width];                                                                \
   for (int i = 0; i < PortName##_width; i++) {                                                                         \
@@ -417,6 +425,14 @@
   }                                                                                                                    \
   (void)PortName;
 
+#define LF_SCOPE_MULTIPORT_TRIGGER(ReactorName, PortName)                                                              \
+  size_t PortName##_width = sizeof(self->PortName) / sizeof(self->PortName[0]);                                        \
+  const ReactorName##_##PortName *PortName[PortName##_width];                                                          \
+  for (int i = 0; i < PortName##_width; i++) {                                                                         \
+    PortName[i] = &self->PortName[i];                                                                                  \
+  }                                                                                                                    \
+  (void)PortName;
+
 #define LF_SCOPE_SELF(ReactorName)                                                                                     \
   ReactorName *self = (ReactorName *)_self->parent;                                                                    \
   (void)self;
@@ -426,11 +442,11 @@
   (void)env;
 
 #define LF_SCOPE_STARTUP(ReactorName)                                                                                  \
-  ReactorName##_Startup *startup = &self->startup;                                                                     \
+  const ReactorName##_Startup *startup = &self->startup;                                                               \
   (void)startup;
 
 #define LF_SCOPE_SHUTDOWN(ReactorName)                                                                                 \
-  ReactorName##_Shutdown *shutdown = &self->shutdown;                                                                  \
+  const ReactorName##_Shutdown *shutdown = &self->shutdown;                                                            \
   (void)shutdown;
 
 #define LF_DEFINE_LOGICAL_CONNECTION_STRUCT(ParentName, ConnName, DownstreamSize)                                      \
diff --git a/lfc/core/src/main/kotlin/org/lflang/generator/uc/UcReactionGenerator.kt b/lfc/core/src/main/kotlin/org/lflang/generator/uc/UcReactionGenerator.kt
index 9d3a853c1..d2cb6a5a9 100644
--- a/lfc/core/src/main/kotlin/org/lflang/generator/uc/UcReactionGenerator.kt
+++ b/lfc/core/src/main/kotlin/org/lflang/generator/uc/UcReactionGenerator.kt
@@ -24,25 +24,26 @@ class UcReactionGenerator(private val reactor: Reactor) {
             return idx
         }
 
-
-
     private val Reaction.ctorDeadlineArg
         get() = if (deadline != null) ", ${deadline.delay.toCCode()}" else ""
-
+    private val Reaction.innerBodyName
+        get() = "${reactor.codeType}_${codeName}"
+    private val Reaction.innerDeadlineHandlerName
+        get() = "${reactor.codeType}_${codeName}_deadline_handler"
     private val Reaction.allUncontainedTriggers
         get() = triggers.filterNot { it.isEffectOf(this) || it.isContainedRef }
     private val Reaction.allUncontainedEffects
         get() = effects.filterNot { it.isContainedRef }
     private val Reaction.allUncontainedSources
         get() = sources.filterNot { it.isContainedRef }
-
     private val Reaction.allContainedEffects
         get() = effects.filter { it.isContainedRef }
     private val Reaction.allContainedTriggers
         get() = triggers.filter { !it.isEffectOf(this) && it.isContainedRef }
     private val Reaction.allContainedSources
         get() = sources.filter { !it.isEffectOf(this) && it.isContainedRef }
-
+    private val Reaction.allVariableReferences get() = (effects + sources + triggers.mapNotNull { it as? VarRef }).distinct()
+    private val Reaction.allReferencedContainers get() = allVariableReferences.mapNotNull { it.container }.distinct()
     private val reactionsWithDeadline = reactor.allReactions.filter {it.deadline != null}
 
     // Calculate the total number of effects, considering that we might write to
@@ -79,24 +80,77 @@ class UcReactionGenerator(private val reactor: Reactor) {
 
     private fun TriggerRef.isEffectOf(reaction: Reaction): Boolean = this is VarRef && isEffectOf(reaction)
 
-    private val TriggerRef.scope
+    private fun Reaction.getInnerParameters(): List<String> =
+        allUncontainedTriggers.map {
+            if (it is VarRef && it.variable is Port && it.variable.isMultiport) {
+                "const ${it.codeType} *${it.name}[], size_t ${it.name}_width"
+            } else {
+                "const ${it.codeType} *${it.name}"
+            }
+        } + allUncontainedSources.map {
+            if (it.variable is Port && it.variable.isMultiport) {
+                "const ${it.codeType} *${it.name}[], size_t ${it.name}_width"
+            } else {
+                "const ${it.codeType} *${it.name}"
+            }
+        } + allUncontainedEffects.map {
+            if (it.variable is Port && it.variable.isMultiport) {
+                "${it.codeType} *${it.name}[], size_t ${it.name}_width"
+            } else {
+                "${it.codeType} *${it.name}"
+            }
+        } + allReferencedContainers.map {
+            if (it.isBank) {
+                "${getContainedStructName(this, it)} ${it.name}[], size_t ${it.name}_width"
+            } else {
+                "${getContainedStructName(this, it)} ${it.name}"
+            }
+        }
+
+    private val TriggerRef.codeType
+        get() = when {
+            this is BuiltinTriggerRef && this.type == BuiltinTrigger.STARTUP -> "${reactor.codeType}_Startup"
+            this is BuiltinTriggerRef && this.type == BuiltinTrigger.SHUTDOWN -> "${reactor.codeType}_Shutdown"
+            this is VarRef -> codeType
+            else -> AssertionError("Unexpected trigger type")
+        }
+
+    private val VarRef.codeType
+        get() = "${reactor.codeType}_${name}"
+
+    private val TriggerRef.scopeTrigger
         get() = when {
             this is BuiltinTriggerRef && this.type == BuiltinTrigger.STARTUP -> "LF_SCOPE_STARTUP(${reactor.codeType});"
             this is BuiltinTriggerRef && this.type == BuiltinTrigger.SHUTDOWN -> "LF_SCOPE_SHUTDOWN(${reactor.codeType});"
-            this is VarRef -> scope
+            this is VarRef -> scopeTrigger
             else -> AssertionError("Unexpected trigger type")
         }
 
-    private val VarRef.scope
+    private val VarRef.scopeTrigger
         get() =
             when (val variable = this.variable) {
                 is Timer -> "LF_SCOPE_TIMER(${reactor.codeType}, ${name});"
-                is Action -> "LF_SCOPE_ACTION(${reactor.codeType}, ${name});"
+                is Action -> "LF_SCOPE_ACTION_TRIGGER(${reactor.codeType}, ${name});"
                 is Port -> {
                     if (variable.width > 1) {
-                        "LF_SCOPE_MULTIPORT(${reactor.codeType}, ${name});"
+                        "LF_SCOPE_MULTIPORT_TRIGGER(${reactor.codeType}, ${name});"
                     } else {
-                        "LF_SCOPE_PORT(${reactor.codeType}, ${name});"
+                        "LF_SCOPE_PORT_TRIGGER(${reactor.codeType}, ${name});"
+                    }
+                }
+                else -> throw AssertionError("Unexpected variable type")
+            }
+
+    private val VarRef.scopeEffect
+        get() =
+            when (val variable = this.variable) {
+                is Timer -> "LF_SCOPE_TIMER(${reactor.codeType}, ${name});"
+                is Action -> "LF_SCOPE_ACTION_EFFECT(${reactor.codeType}, ${name});"
+                is Port -> {
+                    if (variable.width > 1) {
+                        "LF_SCOPE_MULTIPORT_EFFECT(${reactor.codeType}, ${name});"
+                    } else {
+                        "LF_SCOPE_PORT_EFFECT(${reactor.codeType}, ${name});"
                     }
                 }
                 else -> throw AssertionError("Unexpected variable type")
@@ -110,6 +164,9 @@ class UcReactionGenerator(private val reactor: Reactor) {
         reaction.effects.any { name == it.name && container?.name == it.container?.name }
 
 
+    private fun getContainedStructName(reaction: Reaction, inst: Instantiation) =
+        "${reactor.codeType}_${reaction.codeName}_${inst.name}"
+
     private fun registerPortSource(varRef: VarRef, port: Port,  reaction: Reaction) =
         if (varRef.container != null) {
             (0..(varRef.container.width-1)).toList().joinToString(separator = "\n") {
@@ -201,6 +258,35 @@ class UcReactionGenerator(private val reactor: Reactor) {
             postfix = "\n"
         ) { generateReactionBody(it) }
 
+    fun generateReactionInnerBodyDeclarations() =
+        reactor.allReactions.joinToString(
+            separator = "\n",
+            prefix = "// Reaction inner bodies\n",
+            postfix = "\n"
+        ) { "${generateReactionInnerBodyDeclaration(it)};" }
+
+    fun generateReactionInnerArgumentStructs() =
+        reactor.allReactions.joinToString(
+            separator = "\n",
+            prefix = "// Contained reactor argument structs\n",
+            postfix = "\n"
+        ) {
+            generateReactionInnerArgumentStructs(it)
+        }
+
+    fun generateReactionInnerArgumentStructs(reaction: Reaction) =
+        reaction.allContainedEffectsTriggersAndSources.toList()
+            .joinToString(separator = "\n") {
+                generateContainedReactorDefinition(reaction, it.second, it.first)
+            }
+
+    fun generateReactionInnerBodies() =
+        reactor.allReactions.joinToString(
+            separator = "\n",
+            prefix = "// Reaction inner bodies\n",
+            postfix = "\n"
+        ) { generateReactionInnerBodyDefinition(it) }
+
     fun generateReactionDeadlineHandlers() =
         reactionsWithDeadline.joinToString(
             separator = "\n",
@@ -217,6 +303,35 @@ class UcReactionGenerator(private val reactor: Reactor) {
         """.trimMargin()
     }
 
+    private fun generateReactionInnerBodyDeclaration(reaction: Reaction) = with(PrependOperator) {
+        "void ${reaction.innerBodyName}(${reactor.codeType} *self, Environment *env ${reaction.getInnerParameters().joinToString(prefix = ",")})"
+    }
+
+    private fun generateReactionInnerBodyDefinition(reaction: Reaction): String {
+        if (reaction.code == null) return ""
+
+        with(PrependOperator) {
+            return """|
+           |${generateReactionInnerBodyDeclaration(reaction)} {
+           |  // User written reaction body
+        ${"|  "..reaction.code.toText()}
+           |}
+        """.trimMargin()
+        }
+    }
+
+    private fun generateReactionInnerBodyCall(reaction: Reaction): String {
+        with(reaction) {
+            val parameters = allUncontainedTriggers.map { "${it.name} ${if (it is VarRef && it.variable is Input && it.variable.isMultiport) ", ${it.name}_width" else ""}"} +
+                allUncontainedSources.map { "${it.name} ${if (it.variable is Input && it.variable.isMultiport) ", ${it.name}_width" else ""}"} +
+                allUncontainedEffects.map { "${it.name} ${if (it.variable is Output && it.variable.isMultiport) ", ${it.name}_width" else ""}"} +
+                allReferencedContainers.map {
+                    "${it.name} ${if (it.isBank) ", ${it.name}_width" else ""}"
+                }
+            return "${innerBodyName}(self, env ${parameters.joinToString(prefix = ",")});"
+            }
+    }
+
     private fun generateReactionDeadlineHandler(reaction: Reaction) = with(PrependOperator) {
         """
             |LF_DEFINE_REACTION_DEADLINE_HANDLER(${reactor.codeType}, ${reaction.codeName}) {
@@ -231,8 +346,8 @@ class UcReactionGenerator(private val reactor: Reactor) {
         """
             |LF_DEFINE_REACTION_BODY(${reactor.codeType}, ${reaction.codeName}) {
          ${"|  "..generateReactionScope(reaction)}
-            |  // Start of user-witten reaction deadline handler
-         ${"|  "..reaction.code.toText()}
+            |  // Call reaction inner body
+         ${"|  "..generateReactionInnerBodyCall(reaction)}
             |}
         """.trimMargin()
     }
@@ -253,7 +368,6 @@ class UcReactionGenerator(private val reactor: Reactor) {
         """.trimMargin()
     }
 
-
     private fun generateContainedTriggerFieldInit(instName: String, trigger: VarRef) =
         if (trigger.variable.isMultiport) {
             generateContainedMultiportTriggerFieldInit(instName, "&self->${trigger.container.name}[0]", trigger, trigger.variable as Port)
@@ -268,25 +382,25 @@ class UcReactionGenerator(private val reactor: Reactor) {
             "${instName}[i].${trigger.name} = &self->${trigger.container.name}[i].${trigger.name};"
         }
 
-    // FIXME: This must also consider multiports and banks
-    private fun generateContainedReactorScope(triggers: List<VarRef>, inst: Instantiation) = with(PrependOperator) {
+    private fun generateContainedReactorDefinition(reaction: Reaction, triggers: List<VarRef>, inst: Instantiation) = with(PrependOperator) {
         """|
            |// Generated struct providing access to ports of child reactor `${inst.name}`
-           |struct _${inst.reactor.codeType}_${inst.name} {
+           |typedef struct {
         ${"|  "..triggers.joinToString(separator = "\n") { generateContainedTriggerInScope(it) }}
-           |};
-           |struct _${inst.reactor.codeType}_${inst.name} ${inst.name};
-        ${"|"..triggers.joinToString(separator = "\n") {generateContainedTriggerFieldInit("${inst.name}", it)}}
+           |} ${getContainedStructName(reaction, inst)};
         """.trimMargin()
     }
 
-    private fun generateContainedBankScope(triggers: List<VarRef>, inst: Instantiation) = with(PrependOperator) {
+    private fun generateContainedReactorStructDeclaration(reaction: Reaction, triggers: List<VarRef>, inst: Instantiation) = with(PrependOperator) {
         """|
-           |// Generated struct providing access to ports of child reactor `${inst.name}`
-           |struct _${inst.reactor.codeType}_${inst.name} {
-        ${"|  "..triggers.joinToString { generateContainedTriggerInScope(it) }}
-           |};
-           |struct _${inst.reactor.codeType}_${inst.name} ${inst.name}[${inst.width}];
+           | ${getContainedStructName(reaction, inst)} ${inst.name};
+        ${"|"..triggers.joinToString(separator = "\n") {generateContainedTriggerFieldInit("${inst.name}", it)}}
+        """.trimMargin()
+    }
+
+    private fun generateContainedBankStructDeclaration(reaction: Reaction, triggers: List<VarRef>, inst: Instantiation) = with(PrependOperator) {
+        """
+           |${getContainedStructName(reaction, inst)} ${inst.name}[${inst.width}];
            |size_t ${inst.name}_width = ${inst.width};
            |for (int i = 0; i<${inst.width}; i++) {
         ${"|  "..triggers.joinToString(separator = "\n") {generateContainedBankTriggerFieldInit( "${inst.name}", it)}}
@@ -295,16 +409,17 @@ class UcReactionGenerator(private val reactor: Reactor) {
     }
 
     private fun generateTriggersEffectsAndSourcesInScope(reaction: Reaction) =
-        reaction.allUncontainedTriggers.plus(reaction.allUncontainedEffects).plus(reaction.allUncontainedSources)
-            .joinToString(separator = "\n") { with(PrependOperator) { it.scope.toString() } }
+        reaction.allUncontainedTriggers.plus(reaction.allUncontainedSources).filter{it !in reaction.allUncontainedEffects}.distinct().joinToString(prefix = "\n", separator = "\n", postfix="\n"){
+            it.scopeTrigger.toString()
+        } + reaction.allUncontainedEffects.joinToString(separator = "\n") { with(PrependOperator) { it.scopeEffect.toString() } }
 
     private fun generateContainedTriggersAndSourcesInScope(reaction: Reaction) =
         reaction.allContainedEffectsTriggersAndSources.toList()
             .joinToString(separator = "\n") {
                 if (it.first.width > 1) {
-                    generateContainedBankScope(it.second, it.first)
+                    generateContainedBankStructDeclaration(reaction, it.second, it.first)
                 } else {
-                    generateContainedReactorScope(it.second, it.first)
+                    generateContainedReactorStructDeclaration(reaction, it.second, it.first)
                 }
             }
 
diff --git a/lfc/core/src/main/kotlin/org/lflang/generator/uc/UcReactorGenerator.kt b/lfc/core/src/main/kotlin/org/lflang/generator/uc/UcReactorGenerator.kt
index 58186f528..3f0879c7d 100644
--- a/lfc/core/src/main/kotlin/org/lflang/generator/uc/UcReactorGenerator.kt
+++ b/lfc/core/src/main/kotlin/org/lflang/generator/uc/UcReactorGenerator.kt
@@ -49,13 +49,13 @@ class UcReactorGenerator(private val reactor: Reactor, private val fileConfig: U
 
     fun generateReactorPrivatePreamble() = reactor.allPreambles.joinToString(prefix= "// Private preambles\n", separator = "\n", postfix = "\n") { it.code.toText()}
 
+    private val Reactor.includeGuard
+        get(): String = "LFC_GEN_${name.uppercase()}_H"
+
     companion object {
         val Reactor.codeType
             get(): String = "Reactor_$name"
 
-        val Reactor.includeGuard
-            get(): String = "LFC_GEN_${name.uppercase()}_H"
-
         val Reactor.hasStartup
             get(): Boolean = allReactions.filter {
                 it.triggers.filter { it is BuiltinTriggerRef && it.type == BuiltinTrigger.STARTUP }.isNotEmpty()
@@ -154,6 +154,7 @@ class UcReactorGenerator(private val reactor: Reactor, private val fileConfig: U
             |
         ${" |"..instances.generateIncludes()}
         ${" |"..reactions.generateSelfStructs()}
+        ${" |"..reactions.generateReactionInnerArgumentStructs()}
         ${" |"..timers.generateSelfStructs()}
         ${" |"..actions.generateSelfStructs()}
         ${" |"..ports.generateSelfStructs()}
@@ -162,6 +163,7 @@ class UcReactorGenerator(private val reactor: Reactor, private val fileConfig: U
         ${" |"..generateReactorStruct()}
             |
             |${generateReactorCtorSignature()};
+        ${" |"..reactions.generateReactionInnerBodyDeclarations()}
             |
             |#endif // ${reactor.includeGuard}
         """.trimMargin()
@@ -172,6 +174,7 @@ class UcReactorGenerator(private val reactor: Reactor, private val fileConfig: U
             |#include "${headerFile}"
         ${" |"..generateReactorPrivatePreamble()}
         ${" |"..reactions.generateReactionBodies()}
+        ${" |"..reactions.generateReactionInnerBodies()}
         ${" |"..reactions.generateReactionDeadlineHandlers()}
         ${" |"..reactions.generateReactionCtors()}
         ${" |"..actions.generateCtors()}
diff --git a/test/lf/src/Bodyless.lf b/test/lf/src/Bodyless.lf
new file mode 100644
index 000000000..69a8268b2
--- /dev/null
+++ b/test/lf/src/Bodyless.lf
@@ -0,0 +1,9 @@
+target uC {
+  platform: Native,
+  cmake-include: "./lib/bodyless.cmake",
+}
+
+
+main reactor {
+  reaction hello(startup)
+}
\ No newline at end of file
diff --git a/test/lf/src/lib/bodyless.c b/test/lf/src/lib/bodyless.c
new file mode 100644
index 000000000..0a4447abb
--- /dev/null
+++ b/test/lf/src/lib/bodyless.c
@@ -0,0 +1,5 @@
+#include "Bodyless/Bodyless.h"
+
+void Reactor_Bodyless_hello(Reactor_Bodyless *self, Environment *env, const Reactor_Bodyless_Startup *startup) {
+  printf("Hello, World!\n");
+}
\ No newline at end of file
diff --git a/test/lf/src/lib/bodyless.cmake b/test/lf/src/lib/bodyless.cmake
new file mode 100644
index 000000000..fbf6faedc
--- /dev/null
+++ b/test/lf/src/lib/bodyless.cmake
@@ -0,0 +1 @@
+target_sources(${LF_MAIN_TARGET} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/bodyless.c)
\ No newline at end of file
diff --git a/test/unit/action_empty_test.c b/test/unit/action_empty_test.c
index 12d242902..62cd7bb87 100644
--- a/test/unit/action_empty_test.c
+++ b/test/unit/action_empty_test.c
@@ -6,7 +6,7 @@
 LF_DEFINE_REACTION_BODY(ActionLib, reaction) {
   LF_SCOPE_SELF(ActionLib);
   LF_SCOPE_ENV();
-  LF_SCOPE_ACTION(ActionLib, act);
+  LF_SCOPE_ACTION_EFFECT(ActionLib, act);
   TEST_ASSERT_EQUAL(env->get_elapsed_logical_time(env)/MSEC(1), self->cnt);
   lf_schedule(act, MSEC(1));
   self->cnt++;
diff --git a/test/unit/action_microstep_test.c b/test/unit/action_microstep_test.c
index b00d93d89..16baf49a4 100644
--- a/test/unit/action_microstep_test.c
+++ b/test/unit/action_microstep_test.c
@@ -6,7 +6,7 @@
 LF_DEFINE_REACTION_BODY(ActionLib, reaction) {
   LF_SCOPE_SELF(ActionLib);
   LF_SCOPE_ENV();
-  LF_SCOPE_ACTION(ActionLib, act);
+  LF_SCOPE_ACTION_EFFECT(ActionLib, act);
 
   if (self->cnt == 0) {
     TEST_ASSERT_EQUAL(lf_is_present(act), false);
diff --git a/test/unit/action_overwrite_test.c b/test/unit/action_overwrite_test.c
index bdeb56660..50bdccd51 100644
--- a/test/unit/action_overwrite_test.c
+++ b/test/unit/action_overwrite_test.c
@@ -7,7 +7,7 @@
 LF_DEFINE_REACTION_BODY(ActionLib, reaction) {
   LF_SCOPE_SELF(ActionLib);
   LF_SCOPE_ENV();
-  LF_SCOPE_ACTION(ActionLib, act);
+  LF_SCOPE_ACTION_EFFECT(ActionLib, act);
 
   if (self->cnt == 0) {
     TEST_ASSERT_EQUAL(lf_is_present(act), false);
diff --git a/test/unit/action_test.c b/test/unit/action_test.c
index d34735695..37e644f59 100644
--- a/test/unit/action_test.c
+++ b/test/unit/action_test.c
@@ -5,7 +5,7 @@
 
 LF_DEFINE_REACTION_BODY(ActionLib, reaction) {
   LF_SCOPE_SELF(ActionLib);
-  LF_SCOPE_ACTION(ActionLib, act);
+  LF_SCOPE_ACTION_EFFECT(ActionLib, act);
 
   if (self->cnt == 0) {
     // First triggering is from startup reaction, and action should be false.
diff --git a/test/unit/delayed_conn_test.c b/test/unit/delayed_conn_test.c
index f359c0857..1fdddc670 100644
--- a/test/unit/delayed_conn_test.c
+++ b/test/unit/delayed_conn_test.c
@@ -22,7 +22,7 @@ typedef struct {
 LF_DEFINE_REACTION_BODY(Sender, r_sender) {
   LF_SCOPE_SELF(Sender);
   LF_SCOPE_ENV();
-  LF_SCOPE_PORT(Sender, out);
+  LF_SCOPE_PORT_EFFECT(Sender, out);
   // printf("Timer triggered @ %ld\n", env->get_elapsed_logical_time(env));
   lf_set(out, env->get_elapsed_logical_time(env));
 }
@@ -55,7 +55,7 @@ typedef struct {
 LF_DEFINE_REACTION_BODY(Receiver, r_recv) {
   LF_SCOPE_SELF(Receiver);
   LF_SCOPE_ENV();
-  LF_SCOPE_PORT(Receiver, in);
+  LF_SCOPE_PORT_TRIGGER(Receiver, in);
 
   printf("Input triggered @ %ld with %ld\n", env->get_elapsed_logical_time(env), in->value);
   TEST_ASSERT_EQUAL(in->value + MSEC(15), env->get_elapsed_logical_time(env));
diff --git a/test/unit/port_test.c b/test/unit/port_test.c
index 52bbfb8df..c7e51117e 100644
--- a/test/unit/port_test.c
+++ b/test/unit/port_test.c
@@ -22,7 +22,7 @@ typedef struct {
 LF_DEFINE_REACTION_BODY(Sender, r_sender) {
   LF_SCOPE_SELF(Sender);
   LF_SCOPE_ENV();
-  LF_SCOPE_PORT(Sender, out);
+  LF_SCOPE_PORT_EFFECT(Sender, out);
   // printf("Timer triggered @ %ld\n", env->get_elapsed_logical_time(env));
   lf_set(out, env->get_elapsed_logical_time(env));
 }
@@ -54,7 +54,7 @@ typedef struct {
 LF_DEFINE_REACTION_BODY(Receiver, r_recv) {
   LF_SCOPE_SELF(Receiver);
   LF_SCOPE_ENV();
-  LF_SCOPE_PORT(Receiver, in);
+  LF_SCOPE_PORT_TRIGGER(Receiver, in);
 
   printf("Input triggered @ %ld with %ld\n", env->get_elapsed_logical_time(env), in->value);
   TEST_ASSERT_EQUAL(in->value, env->get_elapsed_logical_time(env));
diff --git a/test/unit/request_shutdown_test.c b/test/unit/request_shutdown_test.c
index b2ae79875..d3aa430d5 100644
--- a/test/unit/request_shutdown_test.c
+++ b/test/unit/request_shutdown_test.c
@@ -5,7 +5,7 @@
 LF_DEFINE_REACTION_BODY(ActionLib, reaction) {
   LF_SCOPE_SELF(ActionLib);
   LF_SCOPE_ENV();
-  LF_SCOPE_ACTION(ActionLib, act);
+  LF_SCOPE_ACTION_EFFECT(ActionLib, act);
 
   if (env->get_elapsed_logical_time(env) == MSEC(1)) {
     TEST_ASSERT_EQUAL(2, self->cnt);