diff --git a/include/scratchcpp/block.h b/include/scratchcpp/block.h
index fcdf936f..33a3d5a2 100644
--- a/include/scratchcpp/block.h
+++ b/include/scratchcpp/block.h
@@ -23,7 +23,7 @@ class LIBSCRATCHCPP_EXPORT Block : public Entity
     public:
         friend class Engine;
 
-        Block(const std::string &id, const std::string &opcode);
+        Block(const std::string &id, const std::string &opcode, bool isMonitorBlock = false);
         Block(const Block &) = delete;
 
         CompilerValue *compile(Compiler *compiler);
@@ -90,6 +90,8 @@ class LIBSCRATCHCPP_EXPORT Block : public Entity
 
         InputValue *topLevelReporterInfo();
 
+        bool isMonitorBlock() const;
+
     private:
         void updateInputMap();
         void updateFieldMap();
diff --git a/include/scratchcpp/compiler.h b/include/scratchcpp/compiler.h
index cc7db35a..7930b710 100644
--- a/include/scratchcpp/compiler.h
+++ b/include/scratchcpp/compiler.h
@@ -38,6 +38,13 @@ class LIBSCRATCHCPP_EXPORT Compiler
             Unknown
         };
 
+        enum class CodeType
+        {
+            Script,
+            Reporter,
+            HatPredicate
+        };
+
         using ArgTypes = std::vector<StaticType>;
         using Args = std::vector<CompilerValue *>;
 
@@ -49,7 +56,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
         Target *target() const;
         std::shared_ptr<Block> block() const;
 
-        std::shared_ptr<ExecutableCode> compile(std::shared_ptr<Block> startBlock, bool isHatPredicate = false);
+        std::shared_ptr<ExecutableCode> compile(std::shared_ptr<Block> startBlock, CodeType codeType = CodeType::Script);
         void preoptimize();
 
         CompilerValue *addFunctionCall(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});
diff --git a/include/scratchcpp/executablecode.h b/include/scratchcpp/executablecode.h
index c55a4983..1c5706ad 100644
--- a/include/scratchcpp/executablecode.h
+++ b/include/scratchcpp/executablecode.h
@@ -11,6 +11,7 @@ namespace libscratchcpp
 
 class ExecutionContext;
 class Thread;
+struct ValueData;
 
 /*! \brief The ExecutableCode class represents the code of a compiled Scratch script. */
 class LIBSCRATCHCPP_EXPORT ExecutableCode
@@ -21,6 +22,12 @@ class LIBSCRATCHCPP_EXPORT ExecutableCode
         /*! Runs the script until it finishes or yields. */
         virtual void run(ExecutionContext *context) = 0;
 
+        /*!
+         * Runs the reporter and returns its return value.
+         * \note Make sure to call value_free() to free the value.
+         */
+        virtual ValueData runReporter(ExecutionContext *context) = 0;
+
         /*! Runs the hat predicate and returns its return value. */
         virtual bool runPredicate(ExecutionContext *context) = 0;
 
diff --git a/include/scratchcpp/imonitorhandler.h b/include/scratchcpp/imonitorhandler.h
index 3b72d5f9..e96de1ab 100644
--- a/include/scratchcpp/imonitorhandler.h
+++ b/include/scratchcpp/imonitorhandler.h
@@ -17,8 +17,7 @@ class LIBSCRATCHCPP_EXPORT IMonitorHandler
 
         virtual void init(Monitor *monitor) = 0;
 
-        // TODO: Add onValueChanged()
-        // virtual void onValueChanged(const VirtualMachine *vm) = 0;
+        virtual void onValueChanged(const Value &value) = 0;
         virtual void onXChanged(int x) = 0;
         virtual void onYChanged(int y) = 0;
         virtual void onVisibleChanged(bool visible) = 0;
diff --git a/include/scratchcpp/monitor.h b/include/scratchcpp/monitor.h
index b85decb7..d0527702 100644
--- a/include/scratchcpp/monitor.h
+++ b/include/scratchcpp/monitor.h
@@ -56,8 +56,7 @@ class LIBSCRATCHCPP_EXPORT Monitor : public Entity
 
         const std::string &opcode() const;
 
-        // TODO: Add updateValue()
-        // void updateValue(const VirtualMachine *vm);
+        void updateValue(const Value &value);
 
         void setValueChangeFunction(MonitorChangeFunc f);
         void changeValue(const Value &newValue);
diff --git a/include/scratchcpp/thread.h b/include/scratchcpp/thread.h
index 994de694..7a61529f 100644
--- a/include/scratchcpp/thread.h
+++ b/include/scratchcpp/thread.h
@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "global.h"
+#include "valuedata.h"
 #include "spimpl.h"
 
 namespace libscratchcpp
@@ -27,6 +27,7 @@ class LIBSCRATCHCPP_EXPORT Thread
         Script *script() const;
 
         void run();
+        ValueData runReporter();
         bool runPredicate();
         void kill();
         void reset();
diff --git a/src/blocks/listblocks.cpp b/src/blocks/listblocks.cpp
index 422faec2..fdd15241 100644
--- a/src/blocks/listblocks.cpp
+++ b/src/blocks/listblocks.cpp
@@ -3,6 +3,7 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/compilerconstant.h>
+#include <scratchcpp/block.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/list.h>
 
@@ -27,6 +28,8 @@ Rgb ListBlocks::color() const
 
 void ListBlocks::registerBlocks(IEngine *engine)
 {
+    // Blocks
+    engine->addCompileFunction(this, "data_listcontents", &compileListContents);
     engine->addCompileFunction(this, "data_addtolist", &compileAddToList);
     engine->addCompileFunction(this, "data_deleteoflist", &compileDeleteOfList);
     engine->addCompileFunction(this, "data_deletealloflist", &compileDeleteAllOfList);
@@ -36,6 +39,24 @@ void ListBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "data_itemnumoflist", &compileItemNumOfList);
     engine->addCompileFunction(this, "data_lengthoflist", &compileLengthOfList);
     engine->addCompileFunction(this, "data_listcontainsitem", &compileListContainsItem);
+
+    // Monitor names
+    engine->addMonitorNameFunction(this, "data_listcontents", &listContentsMonitorName);
+}
+
+CompilerValue *ListBlocks::compileListContents(Compiler *compiler)
+{
+    auto list = compiler->field("LIST")->valuePtr();
+    assert(list);
+
+    // If this block is used in a list monitor, return the list pointer
+    if (compiler->block()->isMonitorBlock()) {
+        // TODO: Refactor this
+        // List monitors expect a reference to the list
+        // We don't have a list reference type, so cast the pointer to number
+        return compiler->addConstValue((uintptr_t)list.get());
+    } else
+        return compiler->addListContents(static_cast<List *>(list.get()));
 }
 
 CompilerValue *ListBlocks::compileAddToList(Compiler *compiler)
@@ -194,3 +215,19 @@ CompilerValue *ListBlocks::compileListContainsItem(Compiler *compiler)
 
     return nullptr;
 }
+
+const std::string &ListBlocks::listContentsMonitorName(Block *block)
+{
+    static const std::string empty = "";
+    auto field = block->fieldAt(block->findField("LIST"));
+
+    if (!field)
+        return empty;
+
+    List *list = dynamic_cast<List *>(field->valuePtr().get());
+
+    if (list)
+        return list->name();
+    else
+        return empty;
+}
diff --git a/src/blocks/listblocks.h b/src/blocks/listblocks.h
index 02dbd79c..b6bf6741 100644
--- a/src/blocks/listblocks.h
+++ b/src/blocks/listblocks.h
@@ -19,6 +19,7 @@ class ListBlocks : public IExtension
         void registerBlocks(IEngine *engine) override;
 
     private:
+        static CompilerValue *compileListContents(Compiler *compiler);
         static CompilerValue *compileAddToList(Compiler *compiler);
         static CompilerValue *getListIndex(Compiler *compiler, CompilerValue *input, List *list, CompilerValue *listSize);
         static CompilerValue *compileDeleteOfList(Compiler *compiler);
@@ -29,6 +30,8 @@ class ListBlocks : public IExtension
         static CompilerValue *compileItemNumOfList(Compiler *compiler);
         static CompilerValue *compileLengthOfList(Compiler *compiler);
         static CompilerValue *compileListContainsItem(Compiler *compiler);
+
+        static const std::string &listContentsMonitorName(Block *block);
 };
 
 } // namespace libscratchcpp
diff --git a/src/blocks/variableblocks.cpp b/src/blocks/variableblocks.cpp
index f7600f7c..a0d9f1a9 100644
--- a/src/blocks/variableblocks.cpp
+++ b/src/blocks/variableblocks.cpp
@@ -3,6 +3,7 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/compilerconstant.h>
+#include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/variable.h>
@@ -28,9 +29,16 @@ Rgb VariableBlocks::color() const
 
 void VariableBlocks::registerBlocks(IEngine *engine)
 {
+    // Blocks
     engine->addCompileFunction(this, "data_variable", &compileVariable);
     engine->addCompileFunction(this, "data_setvariableto", &compileSetVariableTo);
     engine->addCompileFunction(this, "data_changevariableby", &compileChangeVariableBy);
+
+    // Monitor names
+    engine->addMonitorNameFunction(this, "data_variable", &variableMonitorName);
+
+    // Monitor change functions
+    engine->addMonitorChangeFunction(this, "data_variable", &changeVariableMonitorValue);
 }
 
 CompilerValue *VariableBlocks::compileVariable(Compiler *compiler)
@@ -70,3 +78,33 @@ CompilerValue *VariableBlocks::compileChangeVariableBy(Compiler *compiler)
 
     return nullptr;
 }
+
+const std::string &VariableBlocks::variableMonitorName(Block *block)
+{
+    static const std::string empty = "";
+
+    auto field = block->fieldAt(block->findField("VARIABLE"));
+
+    if (!field)
+        return empty;
+
+    Variable *var = dynamic_cast<Variable *>(field->valuePtr().get());
+
+    if (var)
+        return var->name();
+    else
+        return empty;
+}
+
+void VariableBlocks::changeVariableMonitorValue(Block *block, const Value &newValue)
+{
+    auto field = block->fieldAt(block->findField("VARIABLE"));
+
+    if (!field)
+        return;
+
+    Variable *var = dynamic_cast<Variable *>(field->valuePtr().get());
+
+    if (var)
+        var->setValue(newValue);
+}
diff --git a/src/blocks/variableblocks.h b/src/blocks/variableblocks.h
index 423085d3..bbae27d8 100644
--- a/src/blocks/variableblocks.h
+++ b/src/blocks/variableblocks.h
@@ -20,6 +20,9 @@ class VariableBlocks : public IExtension
         static CompilerValue *compileVariable(Compiler *compiler);
         static CompilerValue *compileSetVariableTo(Compiler *compiler);
         static CompilerValue *compileChangeVariableBy(Compiler *compiler);
+
+        static const std::string &variableMonitorName(Block *block);
+        static void changeVariableMonitorValue(Block *block, const Value &newValue);
 };
 
 } // namespace libscratchcpp
diff --git a/src/engine/compiler.cpp b/src/engine/compiler.cpp
index 17ea93ce..9fee9506 100644
--- a/src/engine/compiler.cpp
+++ b/src/engine/compiler.cpp
@@ -44,7 +44,7 @@ std::shared_ptr<libscratchcpp::Block> Compiler::block() const
 }
 
 /*! Compiles the script starting with the given block. */
-std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBlock, bool isHatPredicate)
+std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBlock, CodeType codeType)
 {
     BlockPrototype *procedurePrototype = nullptr;
 
@@ -60,14 +60,14 @@ std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBl
         }
     }
 
-    impl->builder = impl->builderFactory->create(impl->ctx, procedurePrototype, isHatPredicate);
+    impl->builder = impl->builderFactory->create(impl->ctx, procedurePrototype, codeType);
     impl->substackTree.clear();
     impl->substackHit = false;
     impl->emptySubstack = false;
     impl->warp = false;
     impl->block = startBlock;
 
-    if (impl->block && isHatPredicate) {
+    if (impl->block && codeType == CodeType::HatPredicate) {
         auto f = impl->block->hatPredicateCompileFunction();
 
         if (f) {
diff --git a/src/engine/internal/codebuilderfactory.cpp b/src/engine/internal/codebuilderfactory.cpp
index 42ea1122..853f283c 100644
--- a/src/engine/internal/codebuilderfactory.cpp
+++ b/src/engine/internal/codebuilderfactory.cpp
@@ -13,10 +13,10 @@ std::shared_ptr<CodeBuilderFactory> CodeBuilderFactory::instance()
     return m_instance;
 }
 
-std::shared_ptr<ICodeBuilder> CodeBuilderFactory::create(CompilerContext *ctx, BlockPrototype *procedurePrototype, bool isPredicate) const
+std::shared_ptr<ICodeBuilder> CodeBuilderFactory::create(CompilerContext *ctx, BlockPrototype *procedurePrototype, Compiler::CodeType codeType) const
 {
     assert(dynamic_cast<LLVMCompilerContext *>(ctx));
-    return std::make_shared<LLVMCodeBuilder>(static_cast<LLVMCompilerContext *>(ctx), procedurePrototype, isPredicate);
+    return std::make_shared<LLVMCodeBuilder>(static_cast<LLVMCompilerContext *>(ctx), procedurePrototype, codeType);
 }
 
 std::shared_ptr<CompilerContext> CodeBuilderFactory::createCtx(IEngine *engine, Target *target) const
diff --git a/src/engine/internal/codebuilderfactory.h b/src/engine/internal/codebuilderfactory.h
index c0c29568..4dac2db7 100644
--- a/src/engine/internal/codebuilderfactory.h
+++ b/src/engine/internal/codebuilderfactory.h
@@ -11,7 +11,7 @@ class CodeBuilderFactory : public ICodeBuilderFactory
 {
     public:
         static std::shared_ptr<CodeBuilderFactory> instance();
-        std::shared_ptr<ICodeBuilder> create(CompilerContext *ctx, BlockPrototype *procedurePrototype, bool isPredicate) const override;
+        std::shared_ptr<ICodeBuilder> create(CompilerContext *ctx, BlockPrototype *procedurePrototype, Compiler::CodeType codeType) const override;
         std::shared_ptr<CompilerContext> createCtx(IEngine *engine, Target *target) const override;
 
     private:
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 4c42540a..54d0715a 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -276,7 +276,7 @@ void Engine::compile()
                     script->setCode(compiler.compile(block));
 
                     if (block->hatPredicateCompileFunction())
-                        script->setHatPredicateCode(compiler.compile(block, true));
+                        script->setHatPredicateCode(compiler.compile(block, Compiler::CodeType::HatPredicate));
                 } else {
                     std::cout << "warning: unsupported top level block: " << block->opcode() << std::endl;
                     m_unsupportedBlocks.insert(block->opcode());
@@ -468,10 +468,10 @@ void Engine::updateMonitors()
             auto script = monitor->script();
 
             if (script) {
-                // TODO: Implement this
-                /*auto thread = script->start();
-                thread->run();
-                monitor->updateValue(thread->vm());*/
+                auto thread = script->start();
+                ValueData value = thread->runReporter();
+                monitor->updateValue(Value(value));
+                value_free(&value);
             }
         }
     }
@@ -1851,7 +1851,35 @@ int Engine::resolveFieldValue(IExtension *extension, const std::string &value) c
 
 void Engine::compileMonitor(std::shared_ptr<Monitor> monitor)
 {
-    // TODO: Implement this
+    Target *target = monitor->sprite() ? static_cast<Target *>(monitor->sprite()) : stage();
+    auto block = monitor->block();
+    auto ext = blockExtension(block->opcode());
+
+    if (ext) {
+        auto ctx = Compiler::createContext(this, target);
+        Compiler compiler(ctx.get());
+        MonitorNameFunc nameFunc = resolveMonitorNameFunc(ext, block->opcode());
+
+        if (nameFunc)
+            monitor->setName(nameFunc(block.get()));
+
+        MonitorChangeFunc changeFunc = resolveMonitorChangeFunc(ext, block->opcode());
+        monitor->setValueChangeFunction(changeFunc);
+
+        auto script = std::make_shared<Script>(target, block, this);
+        monitor->setScript(script);
+        auto code = compiler.compile(block, Compiler::CodeType::Reporter);
+        script->setCode(code);
+        m_monitorCompilerContexts[monitor.get()] = ctx;
+
+        const auto &unsupportedBlocks = compiler.unsupportedBlocks();
+
+        for (const std::string &opcode : unsupportedBlocks)
+            m_unsupportedBlocks.insert(opcode);
+    } else {
+        std::cout << "warning: unsupported monitor block: " << block->opcode() << std::endl;
+        m_unsupportedBlocks.insert(block->opcode());
+    }
 }
 
 void Engine::finalize()
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index 07ec15bc..caa09a70 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -237,6 +237,7 @@ class Engine : public IEngine
 
         std::vector<std::shared_ptr<Target>> m_targets;
         std::unordered_map<Target *, std::shared_ptr<CompilerContext>> m_compilerContexts;
+        std::unordered_map<Monitor *, std::shared_ptr<CompilerContext>> m_monitorCompilerContexts; // TODO: Use shared_ptr in (LLVM)ExecutableCode and remove these maps (might not be a good idea)
         std::vector<std::shared_ptr<Broadcast>> m_broadcasts;
         std::unordered_map<Broadcast *, std::vector<Script *>> m_broadcastMap;
         std::unordered_map<Broadcast *, std::vector<Script *>> m_backdropBroadcastMap;
diff --git a/src/engine/internal/icodebuilderfactory.h b/src/engine/internal/icodebuilderfactory.h
index eecc3c0a..de0b7b8d 100644
--- a/src/engine/internal/icodebuilderfactory.h
+++ b/src/engine/internal/icodebuilderfactory.h
@@ -2,23 +2,20 @@
 
 #pragma once
 
+#include <scratchcpp/compiler.h>
 #include <memory>
 
 namespace libscratchcpp
 {
 
 class ICodeBuilder;
-class CompilerContext;
-class BlockPrototype;
-class Target;
-class IEngine;
 
 class ICodeBuilderFactory
 {
     public:
         virtual ~ICodeBuilderFactory() { }
 
-        virtual std::shared_ptr<ICodeBuilder> create(CompilerContext *ctx, BlockPrototype *procedurePrototype = nullptr, bool isPredicate = false) const = 0;
+        virtual std::shared_ptr<ICodeBuilder> create(CompilerContext *ctx, BlockPrototype *procedurePrototype = nullptr, Compiler::CodeType codeType = Compiler::CodeType::Script) const = 0;
         virtual std::shared_ptr<CompilerContext> createCtx(IEngine *engine, Target *target) const = 0;
 };
 
diff --git a/src/engine/internal/llvm/llvmcodebuilder.cpp b/src/engine/internal/llvm/llvmcodebuilder.cpp
index e212b3cf..19792a21 100644
--- a/src/engine/internal/llvm/llvmcodebuilder.cpp
+++ b/src/engine/internal/llvm/llvmcodebuilder.cpp
@@ -26,7 +26,7 @@ static std::unordered_map<ValueType, Compiler::StaticType>
 static const std::unordered_set<LLVMInstruction::Type>
     VAR_LIST_READ_INSTRUCTIONS = { LLVMInstruction::Type::ReadVariable, LLVMInstruction::Type::GetListItem, LLVMInstruction::Type::GetListItemIndex, LLVMInstruction::Type::ListContainsItem };
 
-LLVMCodeBuilder::LLVMCodeBuilder(LLVMCompilerContext *ctx, BlockPrototype *procedurePrototype, bool isPredicate) :
+LLVMCodeBuilder::LLVMCodeBuilder(LLVMCompilerContext *ctx, BlockPrototype *procedurePrototype, Compiler::CodeType codeType) :
     m_ctx(ctx),
     m_target(ctx->target()),
     m_llvmCtx(*ctx->llvmCtx()),
@@ -35,7 +35,7 @@ LLVMCodeBuilder::LLVMCodeBuilder(LLVMCompilerContext *ctx, BlockPrototype *proce
     m_procedurePrototype(procedurePrototype),
     m_defaultWarp(procedurePrototype ? procedurePrototype->warp() : false),
     m_warp(m_defaultWarp),
-    m_isPredicate(isPredicate)
+    m_codeType(codeType)
 {
     initTypes();
     createVariableMap();
@@ -56,8 +56,8 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
         if (it == m_instructions.end())
             m_warp = true;
 
-        // Do not create coroutine in hat predicates
-        if (m_isPredicate)
+        // Only create coroutines in scripts
+        if (m_codeType != Compiler::CodeType::Script)
             m_warp = true;
     }
 
@@ -1319,15 +1319,32 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     // End and verify the function
     llvm::PointerType *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_llvmCtx), 0);
 
-    if (m_isPredicate) {
-        // Use last instruction return value
-        assert(!m_instructions.empty());
-        m_builder.CreateRet(m_instructions.back()->functionReturnReg->value);
-    } else {
-        if (m_warp)
-            m_builder.CreateRet(llvm::ConstantPointerNull::get(pointerType));
-        else
-            coro->end();
+    switch (m_codeType) {
+        case Compiler::CodeType::Script:
+            if (m_warp)
+                m_builder.CreateRet(llvm::ConstantPointerNull::get(pointerType));
+            else
+                coro->end();
+            break;
+
+        case Compiler::CodeType::Reporter: {
+            // Use last instruction return value (or last constant) and create a ValueData instance
+            assert(!m_instructions.empty() || m_lastConstValue);
+            LLVMRegister *ret = m_instructions.empty() ? m_lastConstValue : m_instructions.back()->functionReturnReg;
+            llvm::Value *copy = createNewValue(ret);
+            m_builder.CreateRet(m_builder.CreateLoad(m_valueDataType, copy));
+            break;
+        }
+
+        case Compiler::CodeType::HatPredicate:
+            // Use last instruction return value (or last constant)
+            assert(!m_instructions.empty() || m_lastConstValue);
+
+            if (m_instructions.empty())
+                m_builder.CreateRet(castValue(m_lastConstValue, Compiler::StaticType::Bool));
+            else
+                m_builder.CreateRet(castValue(m_instructions.back()->functionReturnReg, Compiler::StaticType::Bool));
+            break;
     }
 
     verifyFunction(m_function);
@@ -1349,7 +1366,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
 
     verifyFunction(resumeFunc);
 
-    return std::make_shared<LLVMExecutableCode>(m_ctx, m_function->getName().str(), resumeFunc->getName().str(), m_isPredicate);
+    return std::make_shared<LLVMExecutableCode>(m_ctx, m_function->getName().str(), resumeFunc->getName().str(), m_codeType);
 }
 
 CompilerValue *LLVMCodeBuilder::addFunctionCall(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args)
@@ -1392,6 +1409,7 @@ CompilerConstant *LLVMCodeBuilder::addConstValue(const Value &value)
 {
     auto constReg = std::make_shared<LLVMConstantRegister>(TYPE_MAP[value.type()], value);
     auto reg = std::reinterpret_pointer_cast<LLVMRegister>(constReg);
+    m_lastConstValue = reg.get();
     return static_cast<CompilerConstant *>(static_cast<CompilerValue *>(addReg(reg, nullptr)));
 }
 
@@ -2019,7 +2037,23 @@ void LLVMCodeBuilder::popLoopScope()
 
 std::string LLVMCodeBuilder::getMainFunctionName(BlockPrototype *procedurePrototype)
 {
-    return procedurePrototype ? "proc." + procedurePrototype->procCode() : (m_isPredicate ? "predicate" : "script");
+    std::string name;
+
+    switch (m_codeType) {
+        case Compiler::CodeType::Script:
+            name = "script";
+            break;
+
+        case Compiler::CodeType::Reporter:
+            name = "reporter";
+            break;
+
+        case Compiler::CodeType::HatPredicate:
+            name = "predicate";
+            break;
+    }
+
+    return procedurePrototype ? "proc." + procedurePrototype->procCode() : name;
 }
 
 std::string LLVMCodeBuilder::getResumeFunctionName(BlockPrototype *procedurePrototype)
@@ -2030,6 +2064,7 @@ std::string LLVMCodeBuilder::getResumeFunctionName(BlockPrototype *procedureProt
 llvm::FunctionType *LLVMCodeBuilder::getMainFunctionType(BlockPrototype *procedurePrototype)
 {
     // void *f(ExecutionContext *, Target *, ValueData **, List **, (warp arg), (procedure args...))
+    // ValueData f(...) (reporters)
     // bool f(...) (hat predicates)
     llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_llvmCtx), 0);
     std::vector<llvm::Type *> argTypes = { pointerType, pointerType, pointerType, pointerType };
@@ -2046,7 +2081,23 @@ llvm::FunctionType *LLVMCodeBuilder::getMainFunctionType(BlockPrototype *procedu
         }
     }
 
-    return llvm::FunctionType::get(m_isPredicate ? m_builder.getInt1Ty() : pointerType, argTypes, false);
+    llvm::Type *retType = nullptr;
+
+    switch (m_codeType) {
+        case Compiler::CodeType::Script:
+            retType = pointerType;
+            break;
+
+        case Compiler::CodeType::Reporter:
+            retType = m_valueDataType;
+            break;
+
+        case Compiler::CodeType::HatPredicate:
+            retType = m_builder.getInt1Ty();
+            break;
+    }
+
+    return llvm::FunctionType::get(retType, argTypes, false);
 }
 
 llvm::Function *LLVMCodeBuilder::getOrCreateFunction(const std::string &name, llvm::FunctionType *type)
@@ -2871,6 +2922,17 @@ llvm::Value *LLVMCodeBuilder::createValue(LLVMRegister *reg)
         return reg->value;
 }
 
+llvm::Value *LLVMCodeBuilder::createNewValue(LLVMRegister *reg)
+{
+    // Same as createValue(), but creates a copy of the contents
+    // NOTE: It is the caller's responsibility to free the value.
+    llvm::Value *value = createValue(reg);
+    llvm::Value *ret = addAlloca(m_valueDataType);
+    m_builder.CreateCall(resolve_value_init(), { ret });
+    m_builder.CreateCall(resolve_value_assign_copy(), { ret, value });
+    return ret;
+}
+
 llvm::Value *LLVMCodeBuilder::createComparison(LLVMRegister *arg1, LLVMRegister *arg2, Comparison type)
 {
     auto type1 = arg1->type();
@@ -3341,6 +3403,11 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_string_alloc()
     return resolveFunction("string_alloc", llvm::FunctionType::get(m_builder.getVoidTy(), { m_stringPtrType->getPointerTo(), m_builder.getInt64Ty() }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_string_assign()
+{
+    return resolveFunction("string_assign", llvm::FunctionType::get(m_builder.getVoidTy(), { m_stringPtrType->getPointerTo(), m_stringPtrType->getPointerTo() }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_string_compare_case_sensitive()
 {
     llvm::Type *stringPtr = m_stringPtrType->getPointerTo();
diff --git a/src/engine/internal/llvm/llvmcodebuilder.h b/src/engine/internal/llvm/llvmcodebuilder.h
index 5a765270..68bb517e 100644
--- a/src/engine/internal/llvm/llvmcodebuilder.h
+++ b/src/engine/internal/llvm/llvmcodebuilder.h
@@ -25,7 +25,7 @@ class LLVMLoopScope;
 class LLVMCodeBuilder : public ICodeBuilder
 {
     public:
-        LLVMCodeBuilder(LLVMCompilerContext *ctx, BlockPrototype *procedurePrototype = nullptr, bool isPredicate = false);
+        LLVMCodeBuilder(LLVMCompilerContext *ctx, BlockPrototype *procedurePrototype = nullptr, Compiler::CodeType codeType = Compiler::CodeType::Script);
 
         std::shared_ptr<ExecutableCode> finalize() override;
 
@@ -170,6 +170,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::Value *getListItem(const LLVMListPtr &listPtr, llvm::Value *index);
         llvm::Value *getListItemIndex(const LLVMListPtr &listPtr, LLVMRegister *item);
         llvm::Value *createValue(LLVMRegister *reg);
+        llvm::Value *createNewValue(LLVMRegister *reg);
         llvm::Value *createComparison(LLVMRegister *arg1, LLVMRegister *arg2, Comparison type);
         llvm::Value *createStringComparison(LLVMRegister *arg1, LLVMRegister *arg2, bool caseSensitive);
 
@@ -209,6 +210,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_string_pool_new();
         llvm::FunctionCallee resolve_string_pool_free();
         llvm::FunctionCallee resolve_string_alloc();
+        llvm::FunctionCallee resolve_string_assign();
         llvm::FunctionCallee resolve_string_compare_case_sensitive();
         llvm::FunctionCallee resolve_string_compare_case_insensitive();
 
@@ -235,11 +237,12 @@ class LLVMCodeBuilder : public ICodeBuilder
         std::vector<std::shared_ptr<LLVMInstruction>> m_instructions;
         std::vector<std::shared_ptr<LLVMRegister>> m_regs;
         std::vector<std::shared_ptr<CompilerLocalVariable>> m_localVars;
+        LLVMRegister *m_lastConstValue = nullptr; // for reporters and hat predicates
         BlockPrototype *m_procedurePrototype = nullptr;
         bool m_defaultWarp = false;
         bool m_warp = false;
         int m_defaultArgCount = 0;
-        bool m_isPredicate = false; // for hat predicates
+        Compiler::CodeType m_codeType = Compiler::CodeType::Script;
 
         long m_loopScope = -1; // index
         std::vector<std::shared_ptr<LLVMLoopScope>> m_loopScopes;
diff --git a/src/engine/internal/llvm/llvmexecutablecode.cpp b/src/engine/internal/llvm/llvmexecutablecode.cpp
index f41c660b..5b6a70d8 100644
--- a/src/engine/internal/llvm/llvmexecutablecode.cpp
+++ b/src/engine/internal/llvm/llvmexecutablecode.cpp
@@ -16,11 +16,11 @@
 
 using namespace libscratchcpp;
 
-LLVMExecutableCode::LLVMExecutableCode(LLVMCompilerContext *ctx, const std::string &mainFunctionName, const std::string &resumeFunctionName, bool isPredicate) :
+LLVMExecutableCode::LLVMExecutableCode(LLVMCompilerContext *ctx, const std::string &mainFunctionName, const std::string &resumeFunctionName, Compiler::CodeType codeType) :
     m_ctx(ctx),
     m_mainFunctionName(mainFunctionName),
     m_resumeFunctionName(resumeFunctionName),
-    m_isPredicate(isPredicate)
+    m_codeType(codeType)
 {
     assert(m_ctx);
 
@@ -67,6 +67,14 @@ void LLVMExecutableCode::run(ExecutionContext *context)
     }
 }
 
+ValueData LLVMExecutableCode::runReporter(ExecutionContext *context)
+{
+    assert(std::holds_alternative<ReporterFunctionType>(m_mainFunction));
+    Target *target = context->thread()->target();
+    ReporterFunctionType f = std::get<ReporterFunctionType>(m_mainFunction);
+    return f(context, target, target->variableData(), target->listData());
+}
+
 bool LLVMExecutableCode::runPredicate(ExecutionContext *context)
 {
     assert(std::holds_alternative<PredicateFunctionType>(m_mainFunction));
@@ -101,10 +109,19 @@ std::shared_ptr<ExecutionContext> LLVMExecutableCode::createExecutionContext(Thr
     if (!m_ctx->jitInitialized())
         m_ctx->initJit();
 
-    if (m_isPredicate)
-        m_mainFunction = m_ctx->lookupFunction<PredicateFunctionType>(m_mainFunctionName);
-    else
-        m_mainFunction = m_ctx->lookupFunction<MainFunctionType>(m_mainFunctionName);
+    switch (m_codeType) {
+        case Compiler::CodeType::Script:
+            m_mainFunction = m_ctx->lookupFunction<MainFunctionType>(m_mainFunctionName);
+            break;
+
+        case Compiler::CodeType::Reporter:
+            m_mainFunction = m_ctx->lookupFunction<ReporterFunctionType>(m_mainFunctionName);
+            break;
+
+        case Compiler::CodeType::HatPredicate:
+            m_mainFunction = m_ctx->lookupFunction<PredicateFunctionType>(m_mainFunctionName);
+            break;
+    }
 
     m_resumeFunction = m_ctx->lookupFunction<ResumeFunctionType>(m_resumeFunctionName);
     return std::make_shared<LLVMExecutionContext>(thread);
diff --git a/src/engine/internal/llvm/llvmexecutablecode.h b/src/engine/internal/llvm/llvmexecutablecode.h
index 5526bed5..a4b150b1 100644
--- a/src/engine/internal/llvm/llvmexecutablecode.h
+++ b/src/engine/internal/llvm/llvmexecutablecode.h
@@ -3,6 +3,7 @@
 #pragma once
 
 #include <scratchcpp/executablecode.h>
+#include <scratchcpp/compiler.h>
 #include <scratchcpp/valuedata.h>
 #include <llvm/IR/LLVMContext.h>
 
@@ -16,9 +17,10 @@ class LLVMExecutionContext;
 class LLVMExecutableCode : public ExecutableCode
 {
     public:
-        LLVMExecutableCode(LLVMCompilerContext *ctx, const std::string &mainFunctionName, const std::string &resumeFunctionName, bool isPredicate);
+        LLVMExecutableCode(LLVMCompilerContext *ctx, const std::string &mainFunctionName, const std::string &resumeFunctionName, Compiler::CodeType codeType);
 
         void run(ExecutionContext *context) override;
+        ValueData runReporter(ExecutionContext *context) override;
         bool runPredicate(ExecutionContext *context) override;
         void kill(libscratchcpp::ExecutionContext *context) override;
         void reset(ExecutionContext *context) override;
@@ -29,6 +31,7 @@ class LLVMExecutableCode : public ExecutableCode
 
     private:
         using MainFunctionType = void *(*)(ExecutionContext *, Target *, ValueData **, List **);
+        using ReporterFunctionType = ValueData (*)(ExecutionContext *, Target *, ValueData **, List **);
         using PredicateFunctionType = bool (*)(ExecutionContext *, Target *, ValueData **, List **);
         using ResumeFunctionType = bool (*)(void *);
 
@@ -38,9 +41,9 @@ class LLVMExecutableCode : public ExecutableCode
         std::string m_mainFunctionName;
         std::string m_predicateFunctionName;
         std::string m_resumeFunctionName;
-        bool m_isPredicate = false;
+        Compiler::CodeType m_codeType;
 
-        mutable std::variant<MainFunctionType, PredicateFunctionType> m_mainFunction;
+        mutable std::variant<MainFunctionType, ReporterFunctionType, PredicateFunctionType> m_mainFunction;
         mutable ResumeFunctionType m_resumeFunction = nullptr;
 };
 
diff --git a/src/engine/thread.cpp b/src/engine/thread.cpp
index ddd96647..6279a60d 100644
--- a/src/engine/thread.cpp
+++ b/src/engine/thread.cpp
@@ -60,6 +60,15 @@ void Thread::run()
     string_pool_set_thread(nullptr);
 }
 
+/*! Runs the reporter and returns its return value. */
+ValueData Thread::runReporter()
+{
+    string_pool_set_thread(this);
+    ValueData ret = impl->code->runReporter(impl->executionContext.get());
+    string_pool_set_thread(nullptr);
+    return ret;
+}
+
 /*! Runs the hat predicate and returns its return value. */
 bool Thread::runPredicate()
 {
diff --git a/src/scratch/block.cpp b/src/scratch/block.cpp
index b1fdc8d1..2c188e16 100644
--- a/src/scratch/block.cpp
+++ b/src/scratch/block.cpp
@@ -13,9 +13,9 @@
 using namespace libscratchcpp;
 
 /*! Constructs Block */
-Block::Block(const std::string &id, const std::string &opcode) :
+Block::Block(const std::string &id, const std::string &opcode, bool isMonitorBlock) :
     Entity(id),
-    impl(spimpl::make_unique_impl<BlockPrivate>(opcode))
+    impl(spimpl::make_unique_impl<BlockPrivate>(opcode, isMonitorBlock))
 {
 }
 
@@ -117,6 +117,12 @@ InputValue *Block::topLevelReporterInfo()
         return nullptr;
 }
 
+/*! Returns true if this block belongs to a monitor. */
+bool Block::isMonitorBlock() const
+{
+    return impl->isMonitorBlock;
+}
+
 /*! Returns the next block. */
 std::shared_ptr<Block> Block::next() const
 {
diff --git a/src/scratch/block_p.cpp b/src/scratch/block_p.cpp
index 81dd0bf3..31645729 100644
--- a/src/scratch/block_p.cpp
+++ b/src/scratch/block_p.cpp
@@ -4,7 +4,8 @@
 
 using namespace libscratchcpp;
 
-BlockPrivate::BlockPrivate(const std::string &opcode) :
-    opcode(opcode)
+BlockPrivate::BlockPrivate(const std::string &opcode, bool isMonitorBlock) :
+    opcode(opcode),
+    isMonitorBlock(isMonitorBlock)
 {
 }
diff --git a/src/scratch/block_p.h b/src/scratch/block_p.h
index a1aecb7b..7ae73f67 100644
--- a/src/scratch/block_p.h
+++ b/src/scratch/block_p.h
@@ -18,7 +18,7 @@ class Comment;
 
 struct BlockPrivate
 {
-        BlockPrivate(const std::string &opcode);
+        BlockPrivate(const std::string &opcode, bool isMonitorBlock);
         BlockPrivate(const BlockPrivate &) = delete;
 
         std::string opcode;
@@ -43,6 +43,7 @@ struct BlockPrivate
         bool mutationHasNext = true;
         bool isTopLevelReporter = false;
         std::unique_ptr<InputValue> topLevelReporterInfo = nullptr;
+        bool isMonitorBlock = false;
 };
 
 } // namespace libscratchcpp
diff --git a/src/scratch/monitor.cpp b/src/scratch/monitor.cpp
index d6b847a5..64e8040e 100644
--- a/src/scratch/monitor.cpp
+++ b/src/scratch/monitor.cpp
@@ -115,16 +115,15 @@ const std::string &Monitor::opcode() const
     return impl->block->opcode();
 }
 
-// TODO: Add updateValue()
 /*!
  * Notifies the monitor's interface about value change.
  * The interaface is supposed to read it from the VirtualMachine.
  */
-/*void Monitor::updateValue(const VirtualMachine *vm)
+void Monitor::updateValue(const Value &value)
 {
     if (impl->iface)
-        impl->iface->onValueChanged(vm);
-}*/
+        impl->iface->onValueChanged(value);
+}
 
 /*!
  * Sets the function which is called to change the monitor's value.
@@ -145,10 +144,8 @@ void Monitor::changeValue(const Value &newValue)
     if (impl->changeFunc)
         impl->changeFunc(impl->block.get(), newValue);
 
-    if (impl->iface) {
-        // TODO: Implement this
-        // impl->iface->onValueChanged(...);
-    }
+    if (impl->iface)
+        impl->iface->onValueChanged(newValue);
 }
 
 /*! Returns the monitor's width. */
diff --git a/src/scratch/monitor_p.cpp b/src/scratch/monitor_p.cpp
index bd3b7a6b..f25892a2 100644
--- a/src/scratch/monitor_p.cpp
+++ b/src/scratch/monitor_p.cpp
@@ -9,6 +9,6 @@ using namespace libscratchcpp;
 IRandomGenerator *MonitorPrivate::rng = nullptr;
 
 MonitorPrivate::MonitorPrivate(const std::string &opcode) :
-    block(std::make_shared<Block>("", opcode))
+    block(std::make_shared<Block>("", opcode, true))
 {
 }
diff --git a/src/scratch/string_pool.cpp b/src/scratch/string_pool.cpp
index 00a29056..7e82245f 100644
--- a/src/scratch/string_pool.cpp
+++ b/src/scratch/string_pool.cpp
@@ -8,6 +8,7 @@
 #include <unordered_map>
 #include <map>
 #include <cassert>
+#include <algorithm>
 
 namespace libscratchcpp
 {
@@ -58,6 +59,8 @@ extern "C"
         if (currentThread)
             threadStrings[currentThread].erase(str);
 
+        assert(std::find_if(freeStrings.begin(), freeStrings.end(), [str](const std::pair<size_t, StringPtr *> &p) { return p.second == str; }) == freeStrings.end());
+        assert(std::find_if(strings.begin(), strings.end(), [str](const std::unique_ptr<StringPtr> &p) { return p.get() == str; }) != strings.end());
         freeStrings.insert(std::pair<size_t, StringPtr *>(str->allocatedSize, str));
     }
 }
diff --git a/src/test/scriptbuilder.cpp b/src/test/scriptbuilder.cpp
index 6be3c3b8..5c45a5ce 100644
--- a/src/test/scriptbuilder.cpp
+++ b/src/test/scriptbuilder.cpp
@@ -9,7 +9,9 @@
 #include <scratchcpp/executablecode.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/iengine.h>
+#include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
+#include <scratchcpp/broadcast.h>
 
 #include "scriptbuilder_p.h"
 
@@ -198,7 +200,19 @@ void ScriptBuilder::addEntityField(const std::string &name, std::shared_ptr<Enti
         impl->entities.push_back(entity);
     }
 
-    auto field = std::make_shared<Field>(name, Value(), entity);
+    Value entityName = "";
+    auto var = std::dynamic_pointer_cast<Variable>(entity);
+    auto list = std::dynamic_pointer_cast<List>(entity);
+    auto broadcast = std::dynamic_pointer_cast<Broadcast>(entity);
+
+    if (var)
+        entityName = var->name();
+    else if (list)
+        entityName = list->name();
+    else if (broadcast)
+        entityName = broadcast->name();
+
+    auto field = std::make_shared<Field>(name, entityName, entity);
     impl->lastBlock->addField(field);
 }
 
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index a01da37e..03a354bd 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -65,7 +65,7 @@ TEST_F(EventBlocksTest, WhenTouchingObjectPredicate)
         auto block = builder.currentBlock();
 
         Compiler compiler(&m_engineMock, target.get());
-        auto code = compiler.compile(block, true);
+        auto code = compiler.compile(block, Compiler::CodeType::HatPredicate);
         Script script(target.get(), block, &m_engineMock);
         script.setHatPredicateCode(code);
         Thread thread(target.get(), &m_engineMock, &script);
@@ -89,7 +89,7 @@ TEST_F(EventBlocksTest, WhenTouchingObjectPredicate)
         auto block = builder.currentBlock();
 
         Compiler compiler(&m_engineMock, target.get());
-        auto code = compiler.compile(block, true);
+        auto code = compiler.compile(block, Compiler::CodeType::HatPredicate);
         Script script(target.get(), block, &m_engineMock);
         script.setHatPredicateCode(code);
         Thread thread(target.get(), &m_engineMock, &script);
@@ -113,7 +113,7 @@ TEST_F(EventBlocksTest, WhenTouchingObjectPredicate)
         auto block = builder.currentBlock();
 
         Compiler compiler(&m_engineMock, target.get());
-        auto code = compiler.compile(block, true);
+        auto code = compiler.compile(block, Compiler::CodeType::HatPredicate);
         Script script(target.get(), block, &m_engineMock);
         script.setHatPredicateCode(code);
         Thread thread(target.get(), &m_engineMock, &script);
@@ -137,7 +137,7 @@ TEST_F(EventBlocksTest, WhenTouchingObjectPredicate)
         auto block = builder.currentBlock();
 
         Compiler compiler(&m_engineMock, target.get());
-        auto code = compiler.compile(block, true);
+        auto code = compiler.compile(block, Compiler::CodeType::HatPredicate);
         Script script(target.get(), block, &m_engineMock);
         script.setHatPredicateCode(code);
         Thread thread(target.get(), &m_engineMock, &script);
@@ -155,7 +155,7 @@ TEST_F(EventBlocksTest, WhenTouchingObjectPredicate)
         auto block = builder.currentBlock();
 
         Compiler compiler(&m_engineMock, target.get());
-        auto code = compiler.compile(block, true);
+        auto code = compiler.compile(block, Compiler::CodeType::HatPredicate);
         Script script(target.get(), block, &m_engineMock);
         script.setHatPredicateCode(code);
         Thread thread(target.get(), &m_engineMock, &script);
@@ -274,7 +274,7 @@ TEST_F(EventBlocksTest, WhenGreaterThanPredicate)
         auto block = builder.currentBlock();
 
         Compiler compiler(&m_engineMock, target.get());
-        auto code = compiler.compile(block, true);
+        auto code = compiler.compile(block, Compiler::CodeType::HatPredicate);
         Script script(target.get(), block, &m_engineMock);
         script.setHatPredicateCode(code);
         Thread thread(target.get(), &m_engineMock, &script);
@@ -297,7 +297,7 @@ TEST_F(EventBlocksTest, WhenGreaterThanPredicate)
         auto block = builder.currentBlock();
 
         Compiler compiler(&m_engineMock, target.get());
-        auto code = compiler.compile(block, true);
+        auto code = compiler.compile(block, Compiler::CodeType::HatPredicate);
         Script script(target.get(), block, &m_engineMock);
         script.setHatPredicateCode(code);
         Thread thread(target.get(), &m_engineMock, &script);
diff --git a/test/blocks/list_blocks_test.cpp b/test/blocks/list_blocks_test.cpp
index 2eabb983..323194e0 100644
--- a/test/blocks/list_blocks_test.cpp
+++ b/test/blocks/list_blocks_test.cpp
@@ -8,10 +8,12 @@
 #include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
+#include <scratchcpp/monitor.h>
 #include <scratchcpp/executioncontext.h>
 #include <scratchcpp/executablecode.h>
 #include <enginemock.h>
 #include <randomgeneratormock.h>
+#include <monitorhandlermock.h>
 
 #include "../common.h"
 #include "util.h"
@@ -21,6 +23,8 @@ using namespace libscratchcpp;
 using namespace libscratchcpp::test;
 
 using ::testing::Return;
+using ::testing::Invoke;
+using ::testing::_;
 
 class ListBlocksTest : public testing::Test
 {
@@ -40,6 +44,81 @@ class ListBlocksTest : public testing::Test
         RandomGeneratorMock m_rng;
 };
 
+TEST_F(ListBlocksTest, ListContents)
+{
+    auto target = std::make_shared<Sprite>();
+    auto list1 = std::make_shared<List>("", "");
+    target->addList(list1);
+    auto list2 = std::make_shared<List>("", "");
+    target->addList(list2);
+
+    list1->append(1);
+    list1->append(2);
+    list1->append(4);
+
+    list2->append("Lorem");
+    list2->append("ipsum");
+    list2->append("dolor");
+    list2->append("sit");
+    list2->append("amet");
+
+    ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+    builder.addBlock("data_listcontents");
+    builder.addEntityField("LIST", list1);
+    builder.captureBlockReturnValue();
+
+    builder.addBlock("data_listcontents");
+    builder.addEntityField("LIST", list2);
+    builder.captureBlockReturnValue();
+
+    builder.build();
+
+    builder.run();
+    List *list = builder.capturedValues();
+    ValueData *data = list->data();
+    ASSERT_EQ(list->size(), 2);
+    ASSERT_EQ(Value(data[0]).toString(), "124");
+    ASSERT_EQ(Value(data[1]).toString(), "Lorem ipsum dolor sit amet");
+}
+
+TEST_F(ListBlocksTest, ListMonitor)
+{
+    auto target = std::make_shared<Sprite>();
+    auto list1 = std::make_shared<List>("", "list1");
+    target->addList(list1);
+    auto list2 = std::make_shared<List>("", "list2");
+    target->addList(list2);
+
+    MonitorHandlerMock iface1, iface2;
+    EXPECT_CALL(iface1, init);
+    EXPECT_CALL(iface2, init);
+
+    auto monitor1 = std::make_shared<Monitor>("monitor", "data_listcontents");
+    auto monitor2 = std::make_shared<Monitor>("monitor", "data_listcontents");
+    monitor1->block()->setTarget(target.get());
+    monitor1->setInterface(&iface1);
+    monitor2->block()->setTarget(target.get());
+    monitor2->setInterface(&iface2);
+    m_engine->setMonitors({ monitor1, monitor2 });
+
+    ScriptBuilder builder1(m_extension.get(), m_engine, target);
+    builder1.addBlock(monitor1->block());
+    builder1.addEntityField("LIST", list1);
+
+    ScriptBuilder builder2(m_extension.get(), m_engine, target);
+    builder2.addBlock(monitor2->block());
+    builder2.addEntityField("LIST", list2);
+
+    m_engine->compile();
+    ASSERT_EQ(monitor1->name(), list1->name());
+    ASSERT_EQ(monitor2->name(), list2->name());
+
+    EXPECT_CALL(iface1, onValueChanged(_)).WillOnce(Invoke([list1](const Value &value) { ASSERT_EQ(value.toDouble(), (uintptr_t)list1.get()); }));
+    EXPECT_CALL(iface2, onValueChanged(_)).WillOnce(Invoke([list2](const Value &value) { ASSERT_EQ(value.toDouble(), (uintptr_t)list2.get()); }));
+    m_engine->updateMonitors();
+}
+
 TEST_F(ListBlocksTest, AddToList)
 {
     auto target = std::make_shared<Sprite>();
diff --git a/test/blocks/variable_blocks_test.cpp b/test/blocks/variable_blocks_test.cpp
index 4e2f246e..6d670cef 100644
--- a/test/blocks/variable_blocks_test.cpp
+++ b/test/blocks/variable_blocks_test.cpp
@@ -3,6 +3,8 @@
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <scratchcpp/compiler.h>
+#include <scratchcpp/monitor.h>
+#include <scratchcpp/block.h>
 #include <scratchcpp/test/scriptbuilder.h>
 #include <enginemock.h>
 
@@ -55,6 +57,41 @@ TEST_F(VariableBlocksTest, Variable)
     ASSERT_EQ(Value(values[1]), "Hello world");
 }
 
+TEST_F(VariableBlocksTest, VariableMonitor)
+{
+    auto target = std::make_shared<Sprite>();
+    auto var1 = std::make_shared<Variable>("", "var1", 835.21);
+    target->addVariable(var1);
+    auto var2 = std::make_shared<Variable>("", "var2", "Hello world");
+    target->addVariable(var2);
+
+    auto monitor1 = std::make_shared<Monitor>("monitor", "data_variable");
+    auto monitor2 = std::make_shared<Monitor>("monitor", "data_variable");
+    monitor1->block()->setTarget(target.get());
+    monitor2->block()->setTarget(target.get());
+    m_engine->setMonitors({ monitor1, monitor2 });
+
+    ScriptBuilder builder1(m_extension.get(), m_engine, target);
+    builder1.addBlock(monitor1->block());
+    builder1.addEntityField("VARIABLE", var1);
+
+    ScriptBuilder builder2(m_extension.get(), m_engine, target);
+    builder2.addBlock(monitor2->block());
+    builder2.addEntityField("VARIABLE", var2);
+
+    m_engine->compile();
+    ASSERT_EQ(monitor1->name(), var1->name());
+    ASSERT_EQ(monitor2->name(), var2->name());
+
+    monitor1->changeValue("test");
+    ASSERT_EQ(var1->value().toString(), "test");
+    ASSERT_EQ(var2->value().toString(), "Hello world");
+
+    monitor2->changeValue(-0.25);
+    ASSERT_EQ(var1->value().toString(), "test");
+    ASSERT_EQ(var2->value().toDouble(), -0.25);
+}
+
 TEST_F(VariableBlocksTest, SetVariableTo)
 {
     auto target = std::make_shared<Sprite>();
diff --git a/test/compiler/compiler_test.cpp b/test/compiler/compiler_test.cpp
index 3b823b7b..540f6634 100644
--- a/test/compiler/compiler_test.cpp
+++ b/test/compiler/compiler_test.cpp
@@ -46,12 +46,12 @@ class CompilerTest : public testing::Test
             m_testVar.reset();
         }
 
-        void compile(Compiler *compiler, std::shared_ptr<Block> block, BlockPrototype *procedurePrototype = nullptr, bool isHatPredicate = false)
+        void compile(Compiler *compiler, std::shared_ptr<Block> block, BlockPrototype *procedurePrototype = nullptr, Compiler::CodeType codeType = Compiler::CodeType::Script)
         {
             ASSERT_EQ(compiler->block(), nullptr);
-            EXPECT_CALL(m_builderFactory, create(m_ctx.get(), procedurePrototype, isHatPredicate)).WillOnce(Return(m_builder));
+            EXPECT_CALL(m_builderFactory, create(m_ctx.get(), procedurePrototype, codeType)).WillOnce(Return(m_builder));
             EXPECT_CALL(*m_builder, finalize()).WillOnce(Return(m_code));
-            ASSERT_EQ(compiler->compile(block, isHatPredicate), m_code);
+            ASSERT_EQ(compiler->compile(block, codeType), m_code);
             ASSERT_EQ(compiler->block(), nullptr);
         }
 
@@ -1780,18 +1780,18 @@ TEST_F(CompilerTest, UnsupportedBlocks)
 
     // Hat predicates
     auto block5 = std::make_shared<Block>("b5", "block5");
-    compile(m_compiler.get(), block5, nullptr, true);
+    compile(m_compiler.get(), block5, nullptr, Compiler::CodeType::HatPredicate);
 
     auto block6 = std::make_shared<Block>("b6", "block6");
     block6->setCompileFunction([](Compiler *) -> CompilerValue * { return nullptr; });
-    compile(m_compiler.get(), block6, nullptr, true);
+    compile(m_compiler.get(), block6, nullptr, Compiler::CodeType::HatPredicate);
 
     auto block7 = std::make_shared<Block>("b7", "block7");
     CompilerConstant ret(Compiler::StaticType::Bool, Value(true));
     block7->setCompileFunction([](Compiler *) -> CompilerValue * { return nullptr; });
     block7->setHatPredicateCompileFunction([](Compiler *compiler) -> CompilerValue * { return compiler->addConstValue(true); });
     EXPECT_CALL(*m_builder, addConstValue(Value(true))).WillOnce(Return(&ret));
-    compile(m_compiler.get(), block7, nullptr, true);
+    compile(m_compiler.get(), block7, nullptr, Compiler::CodeType::HatPredicate);
 
     // Check
     ASSERT_EQ(m_compiler->unsupportedBlocks(), std::unordered_set<std::string>({ "block1", "block2", "value_block1", "value_block3", "value_block5", "block4", "block5", "block6" }));
@@ -1846,9 +1846,9 @@ TEST_F(CompilerTest, HatPredicate)
 
     // Script
     EXPECT_CALL(*m_builder, addConstValue(Value(true))).WillOnce(Return(&ret1));
-    compile(m_compiler.get(), block, nullptr, false);
+    compile(m_compiler.get(), block, nullptr, Compiler::CodeType::Script);
 
     // Hat predicate
     EXPECT_CALL(*m_builder, addConstValue(Value(false))).WillOnce(Return(&ret2));
-    compile(m_compiler.get(), block, nullptr, true);
+    compile(m_compiler.get(), block, nullptr, Compiler::CodeType::HatPredicate);
 }
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 991cdca1..47a2c40c 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -12,6 +12,8 @@
 #include <scratchcpp/script.h>
 #include <scratchcpp/thread.h>
 #include <scratchcpp/scratchconfiguration.h>
+#include <scratchcpp/compiler.h>
+#include <scratchcpp/compilerconstant.h>
 #include <scratch/sound_p.h>
 #include <timermock.h>
 #include <clockmock.h>
@@ -189,7 +191,7 @@ TEST(EngineTest, StopSignal)
     }
 }
 
-/*TEST(EngineTest, CompileAndExecuteMonitors)
+TEST(EngineTest, CompileAndExecuteMonitors)
 {
     Engine engine;
     auto stage = std::make_shared<Stage>();
@@ -209,8 +211,8 @@ TEST(EngineTest, StopSignal)
     EXPECT_CALL(*extension, onInit);
     ScratchConfiguration::registerExtension(extension);
     engine.setExtensions({ "MonitorTest" });
-    engine.addCompileFunction(extension.get(), m1->opcode(), [](Compiler *compiler) { compiler->addConstValue(5.4); });
-    engine.addCompileFunction(extension.get(), m2->opcode(), [](Compiler *compiler) { compiler->addConstValue("test"); });
+    engine.addCompileFunction(extension.get(), m1->opcode(), [](Compiler *compiler) -> CompilerValue * { return compiler->addConstValue(5.4); });
+    engine.addCompileFunction(extension.get(), m2->opcode(), [](Compiler *compiler) -> CompilerValue * { return compiler->addConstValue("test"); });
 
     engine.addMonitorNameFunction(extension.get(), m1->opcode(), [](Block *block) -> const std::string & {
         static const std::string testStr = "test";
@@ -229,11 +231,9 @@ TEST(EngineTest, StopSignal)
     auto script3 = m3->script();
     ASSERT_TRUE(script1 && script2 && !script3);
 
-    ASSERT_EQ(script1->bytecodeVector(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT }));
     ASSERT_EQ(script1->target(), stage.get());
     ASSERT_EQ(script1->topBlock(), m1->block());
 
-    ASSERT_EQ(script2->bytecodeVector(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT }));
     ASSERT_EQ(script2->target(), sprite.get());
     ASSERT_EQ(script2->topBlock(), m2->block());
 
@@ -255,16 +255,12 @@ TEST(EngineTest, StopSignal)
     m3->setInterface(&iface3);
 
     EXPECT_CALL(iface1, onValueChanged).Times(0);
-    EXPECT_CALL(iface2, onValueChanged(_)).WillOnce(WithArgs<0>(Invoke([](const VirtualMachine *vm) {
-        ASSERT_EQ(vm->registerCount(), 1);
-        ASSERT_EQ(vm->getInput(0, 1)->toString(), "test");
-        ASSERT_FALSE(vm->atEnd()); // the script shouldn't end because that would spam the console with leak warnings
-    })));
+    EXPECT_CALL(iface2, onValueChanged(_)).WillOnce(WithArgs<0>(Invoke([](const Value &value) { ASSERT_EQ(value.toString(), "test"); })));
     EXPECT_CALL(iface3, onValueChanged).Times(0);
     engine.updateMonitors();
 
     // Change the monitor values
-    testing::internal::CaptureStdout();
+    /*testing::internal::CaptureStdout();
     EXPECT_CALL(iface1, onValueChanged);
     m1->changeValue(0);
     ASSERT_EQ(testing::internal::GetCapturedStdout(), "change 1!\n");
@@ -272,10 +268,10 @@ TEST(EngineTest, StopSignal)
     testing::internal::CaptureStdout();
     EXPECT_CALL(iface2, onValueChanged);
     m2->changeValue(0);
-    ASSERT_EQ(testing::internal::GetCapturedStdout(), "change 2!\n");
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), "change 2!\n");*/
 
     ScratchConfiguration::removeExtension(extension);
-}*/
+}
 
 TEST(EngineTest, IsRunning)
 {
diff --git a/test/llvm/llvmcodebuilder_test.cpp b/test/llvm/llvmcodebuilder_test.cpp
index 86cbfe0b..7fdb93a8 100644
--- a/test/llvm/llvmcodebuilder_test.cpp
+++ b/test/llvm/llvmcodebuilder_test.cpp
@@ -67,12 +67,12 @@ class LLVMCodeBuilderTest : public testing::Test
             test_function(nullptr, nullptr, nullptr, nullptr, nullptr); // force dependency
         }
 
-        void createBuilder(Target *target, BlockPrototype *procedurePrototype, bool isPredicate = false)
+        void createBuilder(Target *target, BlockPrototype *procedurePrototype, Compiler::CodeType codeType = Compiler::CodeType::Script)
         {
             if (m_contexts.find(target) == m_contexts.cend() || !target)
                 m_contexts[target] = std::make_unique<LLVMCompilerContext>(&m_engine, target);
 
-            m_builder = std::make_unique<LLVMCodeBuilder>(m_contexts[target].get(), procedurePrototype, isPredicate);
+            m_builder = std::make_unique<LLVMCodeBuilder>(m_contexts[target].get(), procedurePrototype, codeType);
         }
 
         void createBuilder(Target *target, bool warp)
@@ -82,7 +82,9 @@ class LLVMCodeBuilderTest : public testing::Test
             createBuilder(target, m_procedurePrototype.get());
         }
 
-        void createPredicateBuilder(Target *target) { createBuilder(target, nullptr, true); }
+        void createReporterBuilder(Target *target) { createBuilder(target, nullptr, Compiler::CodeType::Reporter); }
+
+        void createPredicateBuilder(Target *target) { createBuilder(target, nullptr, Compiler::CodeType::HatPredicate); }
 
         void createBuilder(bool warp) { createBuilder(nullptr, warp); }
 
@@ -6005,15 +6007,14 @@ TEST_F(LLVMCodeBuilderTest, HatPredicates)
     // Predicate 1
     createPredicateBuilder(&sprite);
 
-    CompilerValue *v = m_builder->addConstValue(true);
-    m_builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v });
+    m_builder->addConstValue(true);
 
     auto code1 = m_builder->finalize();
 
     // Predicate 2
     createPredicateBuilder(&sprite);
 
-    v = m_builder->addConstValue(false);
+    CompilerValue *v = m_builder->addConstValue(false);
     m_builder->addFunctionCall("test_const_bool", Compiler::StaticType::Bool, { Compiler::StaticType::Bool }, { v });
 
     auto code2 = m_builder->finalize();
@@ -6032,3 +6033,61 @@ TEST_F(LLVMCodeBuilderTest, HatPredicates)
 
     ASSERT_FALSE(code2->runPredicate(ctx.get()));
 }
+
+TEST_F(LLVMCodeBuilderTest, Reporters)
+{
+    Sprite sprite;
+    auto var = std::make_shared<Variable>("", "");
+    var->setValue("Hello world!");
+    sprite.addVariable(var);
+
+    // Reporter 1
+    createReporterBuilder(&sprite);
+
+    m_builder->addConstValue(-45.23);
+
+    auto code1 = m_builder->finalize();
+
+    // Reporter 2
+    createReporterBuilder(&sprite);
+
+    CompilerValue *v = m_builder->addConstValue("test");
+    m_builder->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { v });
+
+    auto code2 = m_builder->finalize();
+
+    // Reporter 3
+    createReporterBuilder(&sprite);
+    m_builder->addVariableValue(var.get());
+
+    auto code3 = m_builder->finalize();
+
+    Script script1(&sprite, nullptr, nullptr);
+    script1.setCode(code1);
+    Thread thread1(&sprite, nullptr, &script1);
+    auto ctx = code1->createExecutionContext(&thread1);
+
+    ValueData ret = code1->runReporter(ctx.get());
+    ASSERT_TRUE(value_isNumber(&ret));
+    ASSERT_EQ(value_toDouble(&ret), -45.23);
+    value_free(&ret);
+
+    Script script2(&sprite, nullptr, nullptr);
+    script2.setCode(code2);
+    Thread thread2(&sprite, nullptr, &script2);
+    ctx = code2->createExecutionContext(&thread2);
+
+    ret = code2->runReporter(ctx.get());
+    ASSERT_EQ(Value(ret).toString(), "test");
+    value_free(&ret);
+
+    Script script3(&sprite, nullptr, nullptr);
+    script3.setCode(code3);
+    Thread thread3(&sprite, nullptr, &script3);
+    ctx = code3->createExecutionContext(&thread3);
+
+    ret = code3->runReporter(ctx.get());
+    var->setValue("abc"); // the string should be copied
+    ASSERT_EQ(Value(ret).toString(), "Hello world!");
+    value_free(&ret);
+}
diff --git a/test/llvm/llvmexecutablecode_test.cpp b/test/llvm/llvmexecutablecode_test.cpp
index f025831e..d792cfde 100644
--- a/test/llvm/llvmexecutablecode_test.cpp
+++ b/test/llvm/llvmexecutablecode_test.cpp
@@ -8,6 +8,7 @@
 #include <engine/internal/llvm/llvmexecutablecode.h>
 #include <engine/internal/llvm/llvmcompilercontext.h>
 #include <engine/internal/llvm/llvmexecutioncontext.h>
+#include <engine/internal/llvm/llvmtypes.h>
 #include <llvm/IR/Module.h>
 #include <llvm/IR/IRBuilder.h>
 #include <enginemock.h>
@@ -29,6 +30,7 @@ class LLVMExecutableCodeTest : public testing::Test
             m_module = m_ctx->module();
             m_llvmCtx = m_ctx->llvmCtx();
             m_builder = std::make_unique<llvm::IRBuilder<>>(*m_llvmCtx);
+            m_valueDataType = LLVMTypes::createValueDataType(m_builder.get());
             test_function(nullptr, nullptr, nullptr, nullptr, nullptr); // force dependency
 
             m_script = std::make_unique<Script>(&m_target, nullptr, &m_engine);
@@ -36,12 +38,29 @@ class LLVMExecutableCodeTest : public testing::Test
 
         inline llvm::Constant *nullPointer() { return llvm::ConstantPointerNull::get(llvm::PointerType::get(llvm::Type::getInt8Ty(*m_llvmCtx), 0)); }
 
-        llvm::Function *beginMainFunction(bool predicate = false)
+        llvm::Function *beginMainFunction(Compiler::CodeType codeType = Compiler::CodeType::Script)
         {
             // void *f(ExecutionContext *, Target *, ValueData **, List **)
+            // ValueData f(...) (reporters)
             // bool f(...) (hat predicates)
             llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(*m_llvmCtx), 0);
-            llvm::FunctionType *funcType = llvm::FunctionType::get(predicate ? m_builder->getInt1Ty() : pointerType, { pointerType, pointerType, pointerType, pointerType }, false);
+            llvm::Type *retType = nullptr;
+
+            switch (codeType) {
+                case Compiler::CodeType::Script:
+                    retType = pointerType;
+                    break;
+
+                case Compiler::CodeType::Reporter:
+                    retType = m_valueDataType;
+                    break;
+
+                case Compiler::CodeType::HatPredicate:
+                    retType = m_builder->getInt1Ty();
+                    break;
+            }
+
+            llvm::FunctionType *funcType = llvm::FunctionType::get(retType, { pointerType, pointerType, pointerType, pointerType }, false);
             llvm::Function *func = llvm::Function::Create(funcType, llvm::Function::ExternalLinkage, "f", m_module);
 
             llvm::BasicBlock *entry = llvm::BasicBlock::Create(*m_llvmCtx, "entry", func);
@@ -62,27 +81,22 @@ class LLVMExecutableCodeTest : public testing::Test
 
         void endFunction(llvm::Value *ret) { m_builder->CreateRet(ret); }
 
-        void addTestFunction(llvm::Function *mainFunc)
+        llvm::Value *addMainFunction(llvm::Function *mainFunc, const std::string testFuncName, llvm::Type *retType)
         {
             auto ptrType = llvm::PointerType::get(llvm::Type::getInt8Ty(*m_llvmCtx), 0);
-            auto func = m_module->getOrInsertFunction("test_function", llvm::FunctionType::get(m_builder->getVoidTy(), { ptrType, ptrType, ptrType, ptrType, ptrType }, false));
+            auto func = m_module->getOrInsertFunction(testFuncName, llvm::FunctionType::get(retType, { ptrType, ptrType, ptrType, ptrType, ptrType }, false));
 
             llvm::Constant *mockInt = llvm::ConstantInt::get(llvm::Type::getInt64Ty(*m_llvmCtx), (uintptr_t)&m_mock, false);
             llvm::Constant *mockPtr = llvm::ConstantExpr::getIntToPtr(mockInt, ptrType);
 
-            m_builder->CreateCall(func, { mockPtr, mainFunc->getArg(0), mainFunc->getArg(1), mainFunc->getArg(2), mainFunc->getArg(3) });
+            return m_builder->CreateCall(func, { mockPtr, mainFunc->getArg(0), mainFunc->getArg(1), mainFunc->getArg(2), mainFunc->getArg(3) });
         }
 
-        llvm::Value *addPredicateFunction(llvm::Function *mainFunc)
-        {
-            auto ptrType = llvm::PointerType::get(llvm::Type::getInt8Ty(*m_llvmCtx), 0);
-            auto func = m_module->getOrInsertFunction("test_predicate", llvm::FunctionType::get(m_builder->getInt1Ty(), { ptrType, ptrType, ptrType, ptrType, ptrType }, false));
+        void addTestFunction(llvm::Function *mainFunc) { addMainFunction(mainFunc, "test_function", m_builder->getVoidTy()); }
 
-            llvm::Constant *mockInt = llvm::ConstantInt::get(llvm::Type::getInt64Ty(*m_llvmCtx), (uintptr_t)&m_mock, false);
-            llvm::Constant *mockPtr = llvm::ConstantExpr::getIntToPtr(mockInt, ptrType);
+        llvm::Value *addReporterFunction(llvm::Function *mainFunc) { return addMainFunction(mainFunc, "test_reporter", m_valueDataType); }
 
-            return m_builder->CreateCall(func, { mockPtr, mainFunc->getArg(0), mainFunc->getArg(1), mainFunc->getArg(2), mainFunc->getArg(3) });
-        }
+        llvm::Value *addPredicateFunction(llvm::Function *mainFunc) { return addMainFunction(mainFunc, "test_predicate", m_builder->getInt1Ty()); }
 
         void addTestPrintFunction(llvm::Value *arg1, llvm::Value *arg2)
         {
@@ -95,6 +109,7 @@ class LLVMExecutableCodeTest : public testing::Test
         llvm::LLVMContext *m_llvmCtx = nullptr;
         llvm::Module *m_module = nullptr;
         std::unique_ptr<llvm::IRBuilder<>> m_builder;
+        llvm::StructType *m_valueDataType = nullptr;
         Target m_target;
         EngineMock m_engine;
         std::unique_ptr<Script> m_script;
@@ -110,7 +125,7 @@ TEST_F(LLVMExecutableCodeTest, CreateExecutionContext)
     endFunction(m_builder->getInt1(true));
 
     {
-        auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), false);
+        auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), Compiler::CodeType::Script);
         m_script->setCode(code);
         Thread thread(&m_target, &m_engine, m_script.get());
         auto ctx = code->createExecutionContext(&thread);
@@ -122,14 +137,33 @@ TEST_F(LLVMExecutableCodeTest, CreateExecutionContext)
 
 TEST_F(LLVMExecutableCodeTest, CreatePredicateExecutionContext)
 {
-    llvm::Function *mainFunc = beginMainFunction(true);
+    llvm::Function *mainFunc = beginMainFunction(Compiler::CodeType::HatPredicate);
     endFunction(m_builder->getInt1(false));
 
     llvm::Function *resumeFunc = beginResumeFunction();
     endFunction(m_builder->getInt1(true));
 
     {
-        auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), true);
+        auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), Compiler::CodeType::HatPredicate);
+        m_script->setCode(code);
+        Thread thread(&m_target, &m_engine, m_script.get());
+        auto ctx = code->createExecutionContext(&thread);
+        ASSERT_TRUE(ctx);
+        ASSERT_EQ(ctx->thread(), &thread);
+        ASSERT_TRUE(dynamic_cast<LLVMExecutionContext *>(ctx.get()));
+    }
+}
+
+TEST_F(LLVMExecutableCodeTest, CreateReporterExecutionContext)
+{
+    llvm::Function *mainFunc = beginMainFunction(Compiler::CodeType::Reporter);
+    endFunction(addReporterFunction(mainFunc));
+
+    llvm::Function *resumeFunc = beginResumeFunction();
+    endFunction(m_builder->getInt1(true));
+
+    {
+        auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), Compiler::CodeType::Reporter);
         m_script->setCode(code);
         Thread thread(&m_target, &m_engine, m_script.get());
         auto ctx = code->createExecutionContext(&thread);
@@ -151,13 +185,13 @@ TEST_F(LLVMExecutableCodeTest, MainFunction)
     llvm::Function *resumeFunc = beginResumeFunction();
     endFunction(m_builder->getInt1(true));
 
-    auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), false);
+    auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), Compiler::CodeType::Script);
     m_script->setCode(code);
     Thread thread(&m_target, &m_engine, m_script.get());
     auto ctx = code->createExecutionContext(&thread);
     ASSERT_FALSE(code->isFinished(ctx.get()));
 
-    EXPECT_CALL(m_mock, f(ctx.get(), &m_target, m_target.variableData(), m_target.listData()));
+    EXPECT_CALL(m_mock, script(ctx.get(), &m_target, m_target.variableData(), m_target.listData()));
     code->run(ctx.get());
     ASSERT_TRUE(code->isFinished(ctx.get()));
 
@@ -170,7 +204,7 @@ TEST_F(LLVMExecutableCodeTest, MainFunction)
     code->kill(ctx.get());
     ASSERT_TRUE(code->isFinished(ctx.get()));
 
-    EXPECT_CALL(m_mock, f).Times(0);
+    EXPECT_CALL(m_mock, script).Times(0);
     code->run(ctx.get());
     ASSERT_TRUE(code->isFinished(ctx.get()));
 
@@ -185,7 +219,7 @@ TEST_F(LLVMExecutableCodeTest, MainFunction)
     ASSERT_FALSE(code->isFinished(anotherCtx.get()));
     ASSERT_TRUE(code->isFinished(ctx.get()));
 
-    EXPECT_CALL(m_mock, f(anotherCtx.get(), &anotherTarget, anotherTarget.variableData(), anotherTarget.listData()));
+    EXPECT_CALL(m_mock, script(anotherCtx.get(), &anotherTarget, anotherTarget.variableData(), anotherTarget.listData()));
     code->run(anotherCtx.get());
     ASSERT_TRUE(code->isFinished(anotherCtx.get()));
     ASSERT_TRUE(code->isFinished(ctx.get()));
@@ -200,13 +234,13 @@ TEST_F(LLVMExecutableCodeTest, PredicateFunction)
     m_target.addVariable(std::make_shared<Variable>("", ""));
     m_target.addList(std::make_shared<List>("", ""));
 
-    llvm::Function *mainFunc = beginMainFunction(true);
+    llvm::Function *mainFunc = beginMainFunction(Compiler::CodeType::HatPredicate);
     endFunction(addPredicateFunction(mainFunc));
 
     llvm::Function *resumeFunc = beginResumeFunction();
     endFunction(m_builder->getInt1(true));
 
-    auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), true);
+    auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), Compiler::CodeType::HatPredicate);
     m_script->setCode(code);
     Thread thread(&m_target, &m_engine, m_script.get());
     auto ctx = code->createExecutionContext(&thread);
@@ -224,6 +258,27 @@ TEST_F(LLVMExecutableCodeTest, PredicateFunction)
     ASSERT_FALSE(code->runPredicate(ctx.get()));
 }
 
+TEST_F(LLVMExecutableCodeTest, ReporterFunction)
+{
+    m_target.addVariable(std::make_shared<Variable>("", ""));
+    m_target.addList(std::make_shared<List>("", ""));
+
+    llvm::Function *mainFunc = beginMainFunction(Compiler::CodeType::Reporter);
+    endFunction(addReporterFunction(mainFunc));
+
+    llvm::Function *resumeFunc = beginResumeFunction();
+    endFunction(m_builder->getInt1(true));
+
+    auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), Compiler::CodeType::Reporter);
+    m_script->setCode(code);
+    Thread thread(&m_target, &m_engine, m_script.get());
+    auto ctx = code->createExecutionContext(&thread);
+
+    Value v = "test";
+    EXPECT_CALL(m_mock, reporter(ctx.get(), &m_target, m_target.variableData(), m_target.listData())).WillOnce(Return(v.data()));
+    ASSERT_EQ(Value(code->runReporter(ctx.get())).toString(), v.toString());
+}
+
 TEST_F(LLVMExecutableCodeTest, Promise)
 {
     llvm::Function *mainFunc = beginMainFunction();
@@ -233,7 +288,7 @@ TEST_F(LLVMExecutableCodeTest, Promise)
     llvm::Function *resumeFunc = beginResumeFunction();
     endFunction(m_builder->getInt1(true));
 
-    auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), false);
+    auto code = std::make_shared<LLVMExecutableCode>(m_ctx.get(), mainFunc->getName().str(), resumeFunc->getName().str(), Compiler::CodeType::Script);
     m_script->setCode(code);
     Thread thread(&m_target, &m_engine, m_script.get());
     auto ctx = code->createExecutionContext(&thread);
@@ -242,7 +297,7 @@ TEST_F(LLVMExecutableCodeTest, Promise)
     // run()
     auto promise = std::make_shared<Promise>();
     ctx->setPromise(promise);
-    EXPECT_CALL(m_mock, f).Times(0);
+    EXPECT_CALL(m_mock, script).Times(0);
 
     for (int i = 0; i < 10; i++) {
         code->run(ctx.get());
@@ -251,7 +306,7 @@ TEST_F(LLVMExecutableCodeTest, Promise)
 
     promise->resolve();
 
-    EXPECT_CALL(m_mock, f);
+    EXPECT_CALL(m_mock, script);
     code->run(ctx.get());
     ASSERT_TRUE(code->isFinished(ctx.get()));
     ASSERT_EQ(ctx->promise(), nullptr);
@@ -260,7 +315,7 @@ TEST_F(LLVMExecutableCodeTest, Promise)
     // kill()
     promise = std::make_shared<Promise>();
     ctx->setPromise(promise);
-    EXPECT_CALL(m_mock, f).Times(0);
+    EXPECT_CALL(m_mock, script).Times(0);
 
     for (int i = 0; i < 10; i++) {
         code->run(ctx.get());
@@ -275,7 +330,7 @@ TEST_F(LLVMExecutableCodeTest, Promise)
     // reset()
     promise = std::make_shared<Promise>();
     ctx->setPromise(promise);
-    EXPECT_CALL(m_mock, f).Times(0);
+    EXPECT_CALL(m_mock, script).Times(0);
 
     for (int i = 0; i < 10; i++) {
         code->run(ctx.get());
@@ -286,7 +341,7 @@ TEST_F(LLVMExecutableCodeTest, Promise)
     ASSERT_FALSE(code->isFinished(ctx.get()));
     ASSERT_EQ(ctx->promise(), nullptr);
 
-    EXPECT_CALL(m_mock, f);
+    EXPECT_CALL(m_mock, script);
     code->run(ctx.get());
     ASSERT_TRUE(code->isFinished(ctx.get()));
 
@@ -301,7 +356,7 @@ TEST_F(LLVMExecutableCodeTest, Promise)
 
     promise = std::make_shared<Promise>();
     anotherCtx->setPromise(promise);
-    EXPECT_CALL(m_mock, f).Times(0);
+    EXPECT_CALL(m_mock, script).Times(0);
 
     for (int i = 0; i < 10; i++) {
         code->run(anotherCtx.get());
@@ -310,7 +365,7 @@ TEST_F(LLVMExecutableCodeTest, Promise)
 
     promise->resolve();
 
-    EXPECT_CALL(m_mock, f);
+    EXPECT_CALL(m_mock, script);
     code->run(anotherCtx.get());
     ASSERT_TRUE(code->isFinished(anotherCtx.get()));
     ASSERT_TRUE(code->isFinished(ctx.get()));
diff --git a/test/llvm/testfunctions.cpp b/test/llvm/testfunctions.cpp
index 3aaccb10..b592b4b8 100644
--- a/test/llvm/testfunctions.cpp
+++ b/test/llvm/testfunctions.cpp
@@ -18,7 +18,15 @@ extern "C"
     void test_function(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData)
     {
         if (mock)
-            mock->f(ctx, target, varData, listData);
+            mock->script(ctx, target, varData, listData);
+    }
+
+    ValueData test_reporter(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData)
+    {
+        if (mock)
+            return mock->reporter(ctx, target, varData, listData);
+
+        return ValueData();
     }
 
     bool test_predicate(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData)
diff --git a/test/llvm/testfunctions.h b/test/llvm/testfunctions.h
index 0a8ded8c..6bd7becf 100644
--- a/test/llvm/testfunctions.h
+++ b/test/llvm/testfunctions.h
@@ -13,6 +13,7 @@ struct StringPtr;
 extern "C"
 {
     void test_function(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData);
+    ValueData test_reporter(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData);
     bool test_predicate(TestMock *mock, ExecutionContext *ctx, Target *target, ValueData **varData, List **listData);
     void test_print_function(ValueData *arg1, ValueData *arg2);
 
diff --git a/test/llvm/testmock.h b/test/llvm/testmock.h
index 14ef3453..bfed10ea 100644
--- a/test/llvm/testmock.h
+++ b/test/llvm/testmock.h
@@ -1,18 +1,19 @@
 #pragma once
 
+#include <scratchcpp/valuedata.h>
 #include <gmock/gmock.h>
 
 namespace libscratchcpp
 {
 
 class Target;
-struct ValueData;
 class List;
 
 class TestMock
 {
     public:
-        MOCK_METHOD(void, f, (ExecutionContext * ctx, Target *, ValueData **, List **));
+        MOCK_METHOD(void, script, (ExecutionContext * ctx, Target *, ValueData **, List **));
+        MOCK_METHOD(ValueData, reporter, (ExecutionContext * ctx, Target *, ValueData **, List **));
         MOCK_METHOD(bool, predicate, (ExecutionContext * ctx, Target *, ValueData **, List **));
 };
 
diff --git a/test/load_project/load_project_test.cpp b/test/load_project/load_project_test.cpp
index 1a3fd10e..850153ef 100644
--- a/test/load_project/load_project_test.cpp
+++ b/test/load_project/load_project_test.cpp
@@ -282,6 +282,7 @@ TEST(LoadProjectTest, LoadTestProject)
         ASSERT_EQ(sprite1->greenFlagBlocks()[0]->y(), 0);
         auto block = sprite1->greenFlagBlocks()[0]->next();
         ASSERT_TRUE(block);
+        ASSERT_FALSE(block->isMonitorBlock());
         ASSERT_EQ(block->parent(), sprite1->greenFlagBlocks()[0]);
         ASSERT_EQ(block->opcode(), "control_forever");
         ASSERT_FALSE(block->isTopLevelReporter());
diff --git a/test/mocks/codebuilderfactorymock.h b/test/mocks/codebuilderfactorymock.h
index 3489995d..d1d1d080 100644
--- a/test/mocks/codebuilderfactorymock.h
+++ b/test/mocks/codebuilderfactorymock.h
@@ -8,6 +8,6 @@ using namespace libscratchcpp;
 class CodeBuilderFactoryMock : public ICodeBuilderFactory
 {
     public:
-        MOCK_METHOD(std::shared_ptr<ICodeBuilder>, create, (CompilerContext *, BlockPrototype *, bool), (const, override));
+        MOCK_METHOD(std::shared_ptr<ICodeBuilder>, create, (CompilerContext *, BlockPrototype *, Compiler::CodeType), (const, override));
         MOCK_METHOD(std::shared_ptr<CompilerContext>, createCtx, (IEngine *, Target *), (const, override));
 };
diff --git a/test/mocks/executablecodemock.h b/test/mocks/executablecodemock.h
index 4d113c26..d0966257 100644
--- a/test/mocks/executablecodemock.h
+++ b/test/mocks/executablecodemock.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <scratchcpp/executablecode.h>
+#include <scratchcpp/valuedata.h>
 #include <gmock/gmock.h>
 
 using namespace libscratchcpp;
@@ -9,6 +10,7 @@ class ExecutableCodeMock : public ExecutableCode
 {
     public:
         MOCK_METHOD(void, run, (ExecutionContext *), (override));
+        MOCK_METHOD(ValueData, runReporter, (ExecutionContext *), (override));
         MOCK_METHOD(bool, runPredicate, (ExecutionContext *), (override));
         MOCK_METHOD(void, kill, (ExecutionContext *), (override));
         MOCK_METHOD(void, reset, (ExecutionContext *), (override));
diff --git a/test/mocks/monitorhandlermock.h b/test/mocks/monitorhandlermock.h
index 132583e1..3d911e77 100644
--- a/test/mocks/monitorhandlermock.h
+++ b/test/mocks/monitorhandlermock.h
@@ -10,8 +10,7 @@ class MonitorHandlerMock : public IMonitorHandler
     public:
         MOCK_METHOD(void, init, (Monitor *), (override));
 
-        // TODO: Add onValueChanged()
-        // MOCK_METHOD(void, onValueChanged, (const VirtualMachine *), (override));
+        MOCK_METHOD(void, onValueChanged, (const Value &), (override));
         MOCK_METHOD(void, onXChanged, (int), (override));
         MOCK_METHOD(void, onYChanged, (int), (override));
         MOCK_METHOD(void, onVisibleChanged, (bool), (override));
diff --git a/test/scratch_classes/block_test.cpp b/test/scratch_classes/block_test.cpp
index a218bc82..a1c55c37 100644
--- a/test/scratch_classes/block_test.cpp
+++ b/test/scratch_classes/block_test.cpp
@@ -33,9 +33,26 @@ class BlockTest : public testing::Test
 
 TEST_F(BlockTest, Constructors)
 {
-    Block block("abc", "motion_movesteps");
-    ASSERT_EQ(block.id(), "abc");
-    ASSERT_EQ(block.opcode(), "motion_movesteps");
+    {
+        Block block("abc", "motion_movesteps");
+        ASSERT_EQ(block.id(), "abc");
+        ASSERT_EQ(block.opcode(), "motion_movesteps");
+        ASSERT_FALSE(block.isMonitorBlock());
+    }
+
+    {
+        Block block("def", "data_listcontents", false);
+        ASSERT_EQ(block.id(), "def");
+        ASSERT_EQ(block.opcode(), "data_listcontents");
+        ASSERT_FALSE(block.isMonitorBlock());
+    }
+
+    {
+        Block block("ghi", "sensing_of", true);
+        ASSERT_EQ(block.id(), "ghi");
+        ASSERT_EQ(block.opcode(), "sensing_of");
+        ASSERT_TRUE(block.isMonitorBlock());
+    }
 }
 
 TEST_F(BlockTest, Next)
diff --git a/test/scratch_classes/monitor_test.cpp b/test/scratch_classes/monitor_test.cpp
index 330ab6d9..fbab7b42 100644
--- a/test/scratch_classes/monitor_test.cpp
+++ b/test/scratch_classes/monitor_test.cpp
@@ -12,7 +12,6 @@
 using namespace libscratchcpp;
 
 using ::testing::Return;
-using ::testing::SaveArg;
 using ::testing::_;
 
 static const int PADDING = 5;
@@ -25,6 +24,7 @@ TEST(MonitorTest, Constructors)
     ASSERT_EQ(monitor.id(), "abc");
     ASSERT_EQ(monitor.opcode(), "test");
     ASSERT_TRUE(monitor.block());
+    ASSERT_TRUE(monitor.block()->isMonitorBlock());
     ASSERT_EQ(monitor.block()->opcode(), "test");
     ASSERT_TRUE(monitor.needsAutoPosition());
 }
@@ -110,26 +110,20 @@ TEST(MonitorTest, Sprite)
     ASSERT_EQ(block->target(), nullptr);
 }
 
-/*TEST(MonitorTest, UpdateValue)
+TEST(MonitorTest, UpdateValue)
 {
     Monitor monitor("", "");
-    VirtualMachine vm1, vm2;
     monitor.updateValue(nullptr);
-    monitor.updateValue(&vm1);
+    monitor.updateValue("test");
 
     MonitorHandlerMock handler;
     EXPECT_CALL(handler, init);
     monitor.setInterface(&handler);
 
-    EXPECT_CALL(handler, onValueChanged(&vm1));
-    monitor.updateValue(&vm1);
-
-    EXPECT_CALL(handler, onValueChanged(nullptr));
-    monitor.updateValue(nullptr);
-
-    EXPECT_CALL(handler, onValueChanged(&vm2));
-    monitor.updateValue(&vm2);
-}*/
+    Value v = 123;
+    EXPECT_CALL(handler, onValueChanged(v));
+    monitor.updateValue(v);
+}
 
 TEST(MonitorTest, ChangeValue)
 {
@@ -140,20 +134,14 @@ TEST(MonitorTest, ChangeValue)
     EXPECT_CALL(handler, init);
     monitor.setInterface(&handler);
 
-    /*const VirtualMachine *vm = nullptr;
-    EXPECT_CALL(handler, onValueChanged(_)).WillOnce(SaveArg<0>(&vm));*/
-    monitor.changeValue(0.25);
-    /*ASSERT_TRUE(vm);
-    ASSERT_EQ(vm->registerCount(), 1);
-    ASSERT_EQ(vm->getInput(0, 1)->toDouble(), 0.25);*/
+    Value v = "test";
+    EXPECT_CALL(handler, onValueChanged(v));
+    monitor.changeValue(v);
 
     monitor.setValueChangeFunction([](Block *block, const Value &newValue) { std::cout << block->opcode() + " " + newValue.toString() << std::endl; });
-    // EXPECT_CALL(handler, onValueChanged(_)).WillOnce(SaveArg<0>(&vm));
+    EXPECT_CALL(handler, onValueChanged(v));
     testing::internal::CaptureStdout();
-    monitor.changeValue("test");
-    /*ASSERT_TRUE(vm);
-    ASSERT_EQ(vm->registerCount(), 1);
-    ASSERT_EQ(vm->getInput(0, 1)->toString(), "test");*/
+    monitor.changeValue(v);
     ASSERT_EQ(testing::internal::GetCapturedStdout(), "test_block test\n");
 }
 
diff --git a/test/test_api/scriptbuilder_test.cpp b/test/test_api/scriptbuilder_test.cpp
index 996b66ce..f9d7fa54 100644
--- a/test/test_api/scriptbuilder_test.cpp
+++ b/test/test_api/scriptbuilder_test.cpp
@@ -9,6 +9,7 @@
 #include <scratchcpp/field.h>
 #include <scratchcpp/list.h>
 #include <scratchcpp/variable.h>
+#include <scratchcpp/broadcast.h>
 
 #include "../common.h"
 #include "testextension.h"
@@ -231,9 +232,9 @@ TEST_F(ScriptBuilderTest, AddEntityInput)
     m_builder->build();
 }
 
-TEST_F(ScriptBuilderTest, AddEntityField)
+TEST_F(ScriptBuilderTest, AddVariableEntityField)
 {
-    auto var = std::make_shared<Variable>("", "");
+    auto var = std::make_shared<Variable>("", "test var");
     m_target->addVariable(var);
 
     m_builder->addBlock("test_simple");
@@ -244,6 +245,7 @@ TEST_F(ScriptBuilderTest, AddEntityField)
     ASSERT_TRUE(block->inputs().empty());
     ASSERT_EQ(block->fields().size(), 1);
     ASSERT_EQ(block->fieldAt(0)->name(), "VARIABLE");
+    ASSERT_EQ(block->fieldAt(0)->value().toString(), "test var");
     ASSERT_EQ(block->fieldAt(0)->valuePtr(), var);
 
     m_builder->addBlock("test_simple");
@@ -251,6 +253,40 @@ TEST_F(ScriptBuilderTest, AddEntityField)
     m_builder->build();
 }
 
+TEST_F(ScriptBuilderTest, AddListEntityField)
+{
+    auto list = std::make_shared<List>("", "hello world");
+    m_target->addList(list);
+
+    m_builder->addBlock("test_simple");
+    m_builder->addEntityField("LIST", list);
+    auto block = m_builder->currentBlock();
+    ASSERT_TRUE(block);
+    ASSERT_EQ(block->opcode(), "test_simple");
+    ASSERT_TRUE(block->inputs().empty());
+    ASSERT_EQ(block->fields().size(), 1);
+    ASSERT_EQ(block->fieldAt(0)->name(), "LIST");
+    ASSERT_EQ(block->fieldAt(0)->value().toString(), "hello world");
+    ASSERT_EQ(block->fieldAt(0)->valuePtr(), list);
+}
+
+TEST_F(ScriptBuilderTest, AddBroadcastEntityField)
+{
+    auto broadcast = std::make_shared<Broadcast>("", "test");
+    m_engine->setBroadcasts({ broadcast });
+
+    m_builder->addBlock("test_simple");
+    m_builder->addEntityField("MESSAGE", broadcast);
+    auto block = m_builder->currentBlock();
+    ASSERT_TRUE(block);
+    ASSERT_EQ(block->opcode(), "test_simple");
+    ASSERT_TRUE(block->inputs().empty());
+    ASSERT_EQ(block->fields().size(), 1);
+    ASSERT_EQ(block->fieldAt(0)->name(), "MESSAGE");
+    ASSERT_EQ(block->fieldAt(0)->value().toString(), "test");
+    ASSERT_EQ(block->fieldAt(0)->valuePtr(), broadcast);
+}
+
 TEST_F(ScriptBuilderTest, CaptureBlockReturnValue)
 {
     m_builder->addBlock("test_teststr");
diff --git a/test/thread/thread_test.cpp b/test/thread/thread_test.cpp
index 687bd76b..aaa3ce53 100644
--- a/test/thread/thread_test.cpp
+++ b/test/thread/thread_test.cpp
@@ -2,6 +2,7 @@
 #include <scratchcpp/script.h>
 #include <scratchcpp/executioncontext.h>
 #include <scratchcpp/promise.h>
+#include <scratchcpp/value.h>
 #include <targetmock.h>
 #include <enginemock.h>
 #include <executablecodemock.h>
@@ -50,6 +51,13 @@ TEST_F(ThreadTest, Run)
     m_thread->run();
 }
 
+TEST_F(ThreadTest, RunReporter)
+{
+    Value v = "test";
+    EXPECT_CALL(*m_code, runReporter(m_ctx.get())).WillOnce(Return(v.data()));
+    ASSERT_EQ(Value(m_thread->runReporter()).toString(), v.toString());
+}
+
 TEST_F(ThreadTest, RunPredicate)
 {
     ASSERT_FALSE(m_thread->runPredicate());