diff --git a/include/scratchcpp/broadcast.h b/include/scratchcpp/broadcast.h
index 0aacdd56..f6e021c7 100644
--- a/include/scratchcpp/broadcast.h
+++ b/include/scratchcpp/broadcast.h
@@ -13,12 +13,14 @@ class BroadcastPrivate;
 class LIBSCRATCHCPP_EXPORT Broadcast : public Entity
 {
     public:
-        Broadcast(const std::string &id, const std::string &name);
+        Broadcast(const std::string &id, const std::string &name, bool isBackdropBroadcast = false);
         Broadcast(const Broadcast &) = delete;
 
         const std::string &name() const;
         void setName(const std::string &newName);
 
+        bool isBackdropBroadcast() const;
+
     private:
         spimpl::unique_impl_ptr<BroadcastPrivate> impl;
 };
diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 7306a2c5..4bb0a045 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -56,11 +56,14 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Starts a script with the given top level block as the given Target (a sprite or the stage). */
         virtual VirtualMachine *startScript(std::shared_ptr<Block> topLevelBlock, Target *) = 0;
 
-        /*! Starts the script of the broadcast with the given index. */
-        virtual void broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait = false) = 0;
+        /*! Starts the scripts of the broadcast with the given index. */
+        virtual void broadcast(unsigned int index) = 0;
 
-        /*! Starts the script of the given broadcast. */
-        virtual void broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait = false) = 0;
+        /*! Starts the scripts of the given broadcast. */
+        virtual void broadcastByPtr(Broadcast *broadcast) = 0;
+
+        /*! Starts the "when backdrop switches to" scripts for the given backdrop broadcast. */
+        virtual void startBackdropScripts(Broadcast *broadcast) = 0;
 
         /*! Stops the given script. */
         virtual void stopScript(VirtualMachine *vm) = 0;
@@ -174,10 +177,10 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual void setSpriteFencingEnabled(bool enable) = 0;
 
         /*! Returns true if there are any running script of the broadcast with the given index. */
-        virtual bool broadcastRunning(unsigned int index, VirtualMachine *sourceScript) = 0;
+        virtual bool broadcastRunning(unsigned int index) = 0;
 
         /*! Returns true if there are any running script of the given broadcast. */
-        virtual bool broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceScript) = 0;
+        virtual bool broadcastByPtrRunning(Broadcast *broadcast) = 0;
 
         /*!
          * Call this from a block implementation to force a redraw (screen refresh).
@@ -242,14 +245,20 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Returns the index of the broadcast with the given ID. */
         virtual int findBroadcastById(const std::string &broadcastId) const = 0;
 
+        /*! Registers the "green flag" script. */
+        virtual void addGreenFlagScript(std::shared_ptr<Block> hatBlock) = 0;
+
         /*! Registers the broadcast script. */
-        virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast) = 0;
+        virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, int fieldId, Broadcast *broadcast) = 0;
+
+        /*! Registers the backdrop change script. */
+        virtual void addBackdropChangeScript(std::shared_ptr<Block> hatBlock, int fieldId) = 0;
 
         /* Registers the given "when I start as clone" script. */
         virtual void addCloneInitScript(std::shared_ptr<Block> hatBlock) = 0;
 
         /* Registers the given "when key pressed" script. */
-        virtual void addKeyPressScript(std::shared_ptr<Block> hatBlock, std::string keyName) = 0;
+        virtual void addKeyPressScript(std::shared_ptr<Block> hatBlock, int fieldId) = 0;
 
         /*! Returns the list of targets. */
         virtual const std::vector<std::shared_ptr<Target>> &targets() const = 0;
diff --git a/include/scratchcpp/script.h b/include/scratchcpp/script.h
index 78afd2d4..bd80c86e 100644
--- a/include/scratchcpp/script.h
+++ b/include/scratchcpp/script.h
@@ -12,6 +12,7 @@ namespace libscratchcpp
 {
 
 class Target;
+class Block;
 class IEngine;
 class Value;
 class VirtualMachine;
@@ -23,10 +24,11 @@ class ScriptPrivate;
 class LIBSCRATCHCPP_EXPORT Script
 {
     public:
-        Script(Target *target, IEngine *engine);
+        Script(Target *target, std::shared_ptr<Block> topBlock, IEngine *engine);
         Script(const Script &) = delete;
 
         Target *target() const;
+        std::shared_ptr<Block> topBlock() const;
 
         unsigned int *bytecode() const;
         const std::vector<unsigned int> &bytecodeVector() const;
diff --git a/include/scratchcpp/virtualmachine.h b/include/scratchcpp/virtualmachine.h
index 3789e8f5..c00a0996 100644
--- a/include/scratchcpp/virtualmachine.h
+++ b/include/scratchcpp/virtualmachine.h
@@ -128,6 +128,7 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
         void replaceReturnValue(const Value &v, unsigned int offset);
 
         void run();
+        void kill();
         void reset();
         void moveToLastCheckpoint();
 
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
index 7cffe7ce..4edd07b7 100644
--- a/src/blocks/eventblocks.cpp
+++ b/src/blocks/eventblocks.cpp
@@ -21,7 +21,7 @@ std::string EventBlocks::name() const
 void EventBlocks::registerBlocks(IEngine *engine)
 {
     // Blocks
-    engine->addHatBlock(this, "event_whenflagclicked");
+    engine->addCompileFunction(this, "event_whenflagclicked", &compileWhenFlagClicked);
     engine->addCompileFunction(this, "event_broadcast", &compileBroadcast);
     engine->addCompileFunction(this, "event_broadcastandwait", &compileBroadcastAndWait);
     engine->addCompileFunction(this, "event_whenbroadcastreceived", &compileWhenBroadcastReceived);
@@ -37,6 +37,11 @@ void EventBlocks::registerBlocks(IEngine *engine)
     engine->addField(this, "KEY_OPTION", KEY_OPTION);
 }
 
+void EventBlocks::compileWhenFlagClicked(Compiler *compiler)
+{
+    compiler->engine()->addGreenFlagScript(compiler->block());
+}
+
 void EventBlocks::compileBroadcast(Compiler *compiler)
 {
     auto input = compiler->input(BROADCAST_INPUT);
@@ -72,60 +77,54 @@ void EventBlocks::compileWhenBroadcastReceived(Compiler *compiler)
 {
     auto broadcast = std::static_pointer_cast<Broadcast>(compiler->field(BROADCAST_OPTION)->valuePtr());
 
-    compiler->engine()->addBroadcastScript(compiler->block(), broadcast.get());
+    compiler->engine()->addBroadcastScript(compiler->block(), BROADCAST_OPTION, broadcast.get());
 }
 
 void EventBlocks::compileWhenBackdropSwitchesTo(Compiler *compiler)
 {
-    if (Stage *stage = compiler->engine()->stage()) {
-        std::string backdropName = compiler->field(BACKDROP)->value().toString();
-        int index = stage->findCostume(backdropName);
-
-        if (index != -1)
-            compiler->engine()->addBroadcastScript(compiler->block(), stage->costumeAt(index)->broadcast());
-    }
+    compiler->engine()->addBackdropChangeScript(compiler->block(), BACKDROP);
 }
 
 void EventBlocks::compileWhenKeyPressed(Compiler *compiler)
 {
     // NOTE: Field values don't have to be registered because keys are referenced by their names
-    compiler->engine()->addKeyPressScript(compiler->block(), compiler->field(KEY_OPTION)->value().toString());
+    compiler->engine()->addKeyPressScript(compiler->block(), KEY_OPTION);
 }
 
 unsigned int EventBlocks::broadcast(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()), vm);
+    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()));
     return 1;
 }
 
 unsigned int EventBlocks::broadcastByIndex(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->getInput(0, 1)->toLong(), vm);
+    vm->engine()->broadcast(vm->getInput(0, 1)->toLong());
     return 1;
 }
 
 unsigned int EventBlocks::broadcastAndWait(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()), vm, true);
+    vm->engine()->broadcast(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()));
     return 1;
 }
 
 unsigned int EventBlocks::broadcastByIndexAndWait(VirtualMachine *vm)
 {
-    vm->engine()->broadcast(vm->getInput(0, 1)->toLong(), vm, true);
+    vm->engine()->broadcast(vm->getInput(0, 1)->toLong());
     return 1;
 }
 
 unsigned int EventBlocks::checkBroadcast(VirtualMachine *vm)
 {
-    if (vm->engine()->broadcastRunning(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString()), vm))
+    if (vm->engine()->broadcastRunning(vm->engine()->findBroadcast(vm->getInput(0, 1)->toString())))
         vm->stop(true, true, true);
     return 1;
 }
 
 unsigned int EventBlocks::checkBroadcastByIndex(VirtualMachine *vm)
 {
-    if (vm->engine()->broadcastRunning(vm->getInput(0, 1)->toLong(), vm))
+    if (vm->engine()->broadcastRunning(vm->getInput(0, 1)->toLong()))
         vm->stop(true, true, true);
     return 1;
 }
diff --git a/src/blocks/eventblocks.h b/src/blocks/eventblocks.h
index 5e9e4502..21f7e812 100644
--- a/src/blocks/eventblocks.h
+++ b/src/blocks/eventblocks.h
@@ -30,6 +30,7 @@ class EventBlocks : public IBlockSection
 
         void registerBlocks(IEngine *engine) override;
 
+        static void compileWhenFlagClicked(Compiler *compiler);
         static void compileBroadcast(Compiler *compiler);
         static void compileBroadcastAndWait(Compiler *compiler);
         static void compileWhenBroadcastReceived(Compiler *compiler);
diff --git a/src/blocks/looksblocks.cpp b/src/blocks/looksblocks.cpp
index eee69eef..ab5290c0 100644
--- a/src/blocks/looksblocks.cpp
+++ b/src/blocks/looksblocks.cpp
@@ -388,6 +388,7 @@ void LooksBlocks::compileSwitchBackdropToAndWait(Compiler *compiler)
         compiler->addFunctionCall(&switchBackdropToAndWait);
     }
 
+    compiler->addFunctionCall(&backdropNumber);
     compiler->addFunctionCall(&checkBackdropScripts);
 }
 
@@ -750,7 +751,7 @@ void LooksBlocks::startBackdropScripts(VirtualMachine *vm, bool wait)
 {
     if (Stage *stage = vm->engine()->stage()) {
         if (stage->costumes().size() > 0)
-            vm->engine()->broadcastByPtr(stage->currentCostume()->broadcast(), vm, wait);
+            vm->engine()->startBackdropScripts(stage->currentCostume()->broadcast());
     }
 }
 
@@ -894,11 +895,14 @@ unsigned int LooksBlocks::randomBackdropAndWait(VirtualMachine *vm)
 unsigned int LooksBlocks::checkBackdropScripts(VirtualMachine *vm)
 {
     if (Stage *stage = vm->engine()->stage()) {
-        if ((stage->costumes().size() > 0) && vm->engine()->broadcastByPtrRunning(stage->currentCostume()->broadcast(), vm))
+        long index = vm->getInput(0, 1)->toLong() - 1;
+        assert(stage->costumes().size() == 0 || index >= 0);
+
+        if ((stage->costumes().size() > 0) && vm->engine()->broadcastByPtrRunning(stage->costumeAt(index)->broadcast()))
             vm->stop(true, true, true);
     }
 
-    return 0;
+    return 1;
 }
 
 unsigned int LooksBlocks::goToFront(VirtualMachine *vm)
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index b85d4876..58df9aac 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -23,10 +23,18 @@
 #include "blocksectioncontainer.h"
 #include "timer.h"
 #include "clock.h"
-#include "../../blocks/standardblocks.h"
+#include "blocks/standardblocks.h"
 
 using namespace libscratchcpp;
 
+const std::unordered_map<Engine::HatType, bool> Engine::m_hatRestartExistingThreads = {
+    { HatType::GreenFlag, true },
+    { HatType::BroadcastReceived, true },
+    { HatType::BackdropChanged, true },
+    { HatType::CloneInit, false },
+    { HatType::KeyPressed, false }
+};
+
 Engine::Engine() :
     m_defaultTimer(std::make_unique<Timer>()),
     m_timer(m_defaultTimer.get()),
@@ -112,7 +120,7 @@ void Engine::compile()
             if (block->topLevel() && !block->shadow()) {
                 auto section = blockSection(block->opcode());
                 if (section) {
-                    auto script = std::make_shared<Script>(target.get(), this);
+                    auto script = std::make_shared<Script>(target.get(), block, this);
                     m_scripts[block] = script;
 
                     compiler.compile(block);
@@ -156,92 +164,70 @@ void Engine::start()
     m_timer->reset();
     m_running = true;
 
-    for (auto target : m_targets) {
-        auto gfBlocks = target->greenFlagBlocks();
-        for (auto block : gfBlocks)
-            startScript(block, target.get());
-    }
+    // Start "when green flag clicked" scripts
+    startHats(HatType::GreenFlag, {}, nullptr);
 
     m_eventLoopMutex.unlock();
 }
 
 void Engine::stop()
 {
-    finalize();
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L2057-L2081
     deleteClones();
+
+    if (m_activeThread) {
+        stopThread(m_activeThread.get());
+        // NOTE: The project should continue running even after "stop all" is called and the remaining threads should be stepped once.
+        // The remaining threads can even start new threads which will ignore the "stop all" call and will "restart" the project.
+        // This is probably a bug in the Scratch VM, but let's keep it here to keep it compatible.
+        m_threadsToStop = m_threads;
+    } else {
+        // If there isn't any active thread, it means the project was stopped from the outside
+        // In this case all threads should be removed and the project should be considered stopped
+        m_threads.clear();
+        m_running = false;
+    }
 }
 
 VirtualMachine *Engine::startScript(std::shared_ptr<Block> topLevelBlock, Target *target)
 {
-    if (!topLevelBlock) {
-        std::cout << "warning: starting a script with a null top level block (nothing will happen)" << std::endl;
-        return nullptr;
-    }
-
-    if (!target) {
-        std::cout << "error: scripts must be started by a target";
-        assert(false);
-        return nullptr;
-    }
-
-    if (topLevelBlock->next()) {
-        auto script = m_scripts[topLevelBlock];
-        std::shared_ptr<VirtualMachine> vm = script->start(target);
-        addRunningScript(vm);
-        return vm.get();
-    }
-
-    return nullptr;
+    return pushThread(topLevelBlock, target).get();
 }
 
-void Engine::broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait)
+void Engine::broadcast(unsigned int index)
 {
     if (index < 0 || index >= m_broadcasts.size())
         return;
 
-    broadcastByPtr(m_broadcasts[index].get(), sourceScript, wait);
+    broadcastByPtr(m_broadcasts[index].get());
 }
 
-void Engine::broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait)
+void Engine::broadcastByPtr(Broadcast *broadcast)
 {
-    const std::vector<Script *> &scripts = m_broadcastMap[broadcast];
-    auto &runningBroadcasts = m_runningBroadcastMap[broadcast];
-
-    for (auto script : scripts) {
-        for (auto &pair : runningBroadcasts) {
-            if (pair.second->script() == script)
-                pair.first = sourceScript;
-        }
-
-        if (script == sourceScript->script())
-            sourceScript->stop(false, !wait); // source script is the broadcast script
-    }
-
-    std::vector<VirtualMachine *> startedScripts = startHats(scripts);
+    startHats(HatType::BroadcastReceived, { { HatField::BroadcastOption, broadcast } }, nullptr);
+}
 
-    for (VirtualMachine *vm : startedScripts)
-        runningBroadcasts.push_back({ sourceScript, vm });
+void Engine::startBackdropScripts(Broadcast *broadcast)
+{
+    startHats(HatType::BackdropChanged, { { HatField::Backdrop, broadcast->name() } }, nullptr);
 }
 
 void Engine::stopScript(VirtualMachine *vm)
 {
-    assert(vm);
-    if (std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm) == m_scriptsToRemove.end())
-        m_scriptsToRemove.push_back(vm);
+    stopThread(vm);
 }
 
 void Engine::stopTarget(Target *target, VirtualMachine *exceptScript)
 {
-    const auto &targetScripts = m_runningScripts[target];
-    std::vector<VirtualMachine *> scripts;
+    std::vector<VirtualMachine *> threads;
 
-    for (auto script : targetScripts) {
-        if ((script->target() == target) && (script.get() != exceptScript))
-            scripts.push_back(script.get());
+    for (auto thread : m_threads) {
+        if ((thread->target() == target) && (thread.get() != exceptScript))
+            threads.push_back(thread.get());
     }
 
-    for (auto script : scripts)
-        stopScript(script);
+    for (auto thread : threads)
+        stopThread(thread);
 }
 
 void Engine::initClone(std::shared_ptr<Sprite> clone)
@@ -255,24 +241,13 @@ void Engine::initClone(std::shared_ptr<Sprite> clone)
     if (!root)
         return;
 
-    auto it = m_cloneInitScriptsMap.find(root);
-
-    if (it != m_cloneInitScriptsMap.cend()) {
-        const auto &scripts = it->second;
-
 #ifndef NDEBUG
-        // Since we're initializing the clone, it shouldn't have any running scripts
-        for (const auto &[target, targetScripts] : m_runningScripts) {
-            for (const auto script : targetScripts)
-                assert((target != clone.get()) || (std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), script.get()) != m_scriptsToRemove.end()));
-        }
+    // Since we're initializing the clone, it shouldn't have any running scripts
+    for (auto thread : m_threads)
+        assert(thread->target() != clone.get() || thread->atEnd());
 #endif
 
-        for (auto script : scripts) {
-            auto vm = script->start(clone.get());
-            addRunningScript(vm);
-        }
-    }
+    startHats(HatType::CloneInit, {}, clone.get());
 
     assert(std::find(m_clones.begin(), m_clones.end(), clone) == m_clones.end());
     assert(std::find(m_executableTargets.begin(), m_executableTargets.end(), clone.get()) == m_executableTargets.end());
@@ -310,160 +285,129 @@ void Engine::setRedrawHandler(const std::function<void()> &handler)
     m_redrawHandler = handler;
 }
 
-void Engine::eventLoop(bool untilProjectStops)
+void Engine::step()
 {
-    updateFrameDuration();
-    m_newScripts.clear();
-    m_stopEventLoop = false;
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L2087C6-L2155
 
-    while (true) {
-        auto frameStart = m_clock->currentSteadyTime();
-        std::chrono::steady_clock::time_point currentTime;
-        std::chrono::milliseconds elapsedTime, sleepTime;
-        m_redrawRequested = false;
-        bool timeout = false;
-        bool stop = false;
-        // TODO: Avoid copying by passing current size to runScripts()
-        TargetScriptMap scripts = m_runningScripts; // this must be copied (for now)
-
-        do {
-            m_eventLoopMutex.lock();
-            m_scriptsToRemove.clear();
-
-            // Execute new scripts from last frame
-            runScripts(m_newScripts, scripts);
-
-            // Execute all running scripts
-            m_newScripts.clear();
-            runScripts(scripts, scripts);
-
-            // Stop the event loop if the project has finished running (and untilProjectStops is set to true)
-            if (untilProjectStops) {
-                bool empty = true;
-
-                for (const auto &pair : m_runningScripts) {
-                    if (!pair.second.empty()) {
-                        empty = false;
-                        m_eventLoopMutex.unlock();
-                        break;
-                    }
-                }
-
-                if (empty) {
-                    stop = true;
-                    m_eventLoopMutex.unlock();
-                    break;
-                }
-            }
-
-            // Stop the event loop if stopEventLoop() was called
-            m_stopEventLoopMutex.lock();
-
-            if (m_stopEventLoop) {
-                stop = true;
-                m_eventLoopMutex.unlock();
-                break;
-            }
-
-            m_stopEventLoopMutex.unlock();
-
-            currentTime = m_clock->currentSteadyTime();
-            elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - frameStart);
-            sleepTime = m_frameDuration - elapsedTime;
-            timeout = sleepTime <= std::chrono::milliseconds::zero();
-            m_eventLoopMutex.unlock();
-        } while (!((m_redrawRequested && !m_turboModeEnabled) || timeout || stop));
+    // Clean up threads that were told to stop during or since the last step
+    m_threads.erase(std::remove_if(m_threads.begin(), m_threads.end(), [](std::shared_ptr<VirtualMachine> thread) { return thread->atEnd(); }), m_threads.end());
 
-        if (stop)
-            break;
-
-        // Redraw
-        if (m_redrawHandler)
-            m_redrawHandler();
+    m_redrawRequested = false;
 
-        // If the timeout hasn't been reached yet (redraw was requested), sleep
-        if (!timeout)
-            m_clock->sleep(sleepTime);
-    }
+    // Step threads
+    stepThreads();
 
-    finalize();
+    // Render
+    if (m_redrawHandler)
+        m_redrawHandler();
 }
 
-void Engine::runScripts(const TargetScriptMap &scriptMap, TargetScriptMap &globalScriptMap)
+std::vector<std::shared_ptr<VirtualMachine>> Engine::stepThreads()
 {
-    // globalScriptMap is used to remove "scripts to remove" from it so that they're removed from the correct list
-    for (int i = m_executableTargets.size() - 1; i >= 0; i--) {
-        auto it = scriptMap.find(m_executableTargets[i]);
+    // https://github.com/scratchfoundation/scratch-vm/blob/develop/src/engine/sequencer.js#L70-L173
+    const double WORK_TIME = 0.75 * m_frameDuration.count(); // 75% of frame duration
+    assert(WORK_TIME > 0);
+    auto stepStart = m_clock->currentSteadyTime();
 
-        if ((it == scriptMap.cend()) || it->second.empty())
-            continue; // skip the target if it doesn't have any running script
+    size_t numActiveThreads = 1; // greater than zero
+    std::vector<std::shared_ptr<VirtualMachine>> doneThreads;
 
-        const auto &scripts = it->second;
+    auto elapsedTime = [this, &stepStart]() {
+        std::chrono::steady_clock::time_point currentTime = m_clock->currentSteadyTime();
+        std::chrono::milliseconds elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - stepStart);
+        return elapsedTime.count();
+    };
 
-        for (int i = 0; i < scripts.size(); i++) {
-            auto script = scripts[i];
-            assert(script);
+    while (!m_threads.empty() && numActiveThreads > 0 && elapsedTime() < WORK_TIME && (m_turboModeEnabled || !m_redrawRequested)) {
+        numActiveThreads = 0;
 
-            if (std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), script.get()) != m_scriptsToRemove.end())
-                continue; // skip the script if it is scheduled to be removed
+        // Attempt to run each thread one time
+        for (int i = 0; i < m_threads.size(); i++) {
+            assert(i >= 0 && i < m_threads.size());
+            m_activeThread = m_threads[i];
 
-            script->run();
-
-            if (script->atEnd() && m_running) {
-                if (std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), script.get()) == m_scriptsToRemove.end())
-                    m_scriptsToRemove.push_back(script.get());
+            // Check if the thread is done so it is not executed
+            if (m_activeThread->atEnd()) {
+                // Finished with this thread
+                continue;
             }
+
+            stepThread(m_activeThread);
+
+            if (!m_activeThread->atEnd())
+                numActiveThreads++;
         }
+
+        // Remove threads in m_threadsToStop
+        for (auto thread : m_threadsToStop)
+            m_threads.erase(std::remove(m_threads.begin(), m_threads.end(), thread), m_threads.end());
+
+        // Remove inactive threads (and add them to doneThreads)
+        m_threads.erase(
+            std::remove_if(
+                m_threads.begin(),
+                m_threads.end(),
+                [&doneThreads](std::shared_ptr<VirtualMachine> thread) {
+                    if (thread->atEnd()) {
+                        doneThreads.push_back(thread);
+                        return true;
+                    } else
+                        return false;
+                }),
+            m_threads.end());
     }
 
-    assert(m_running || m_scriptsToRemove.empty());
+    if (m_threads.empty())
+        m_running = false;
 
-    for (auto script : m_scriptsToRemove) {
-        auto pred = [script](std::shared_ptr<VirtualMachine> vm) { return vm.get() == script; };
-#ifndef NDEBUG
-        bool found = false;
-#endif
+    m_activeThread = nullptr;
+    return doneThreads;
+}
 
-        // Remove from m_runningScripts
-        for (auto &[target, scripts] : m_runningScripts) {
-            auto it = std::find_if(scripts.begin(), scripts.end(), pred);
+void Engine::stepThread(std::shared_ptr<VirtualMachine> thread)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/develop/src/engine/sequencer.js#L179-L276
+    thread->run();
+}
 
-            if (it != scripts.end()) {
-                scripts.erase(it);
-#ifndef NDEBUG
-                found = true;
-#endif
-                break;
-            }
-        }
+void Engine::eventLoop(bool untilProjectStops)
+{
+    updateFrameDuration();
+    m_stopEventLoop = false;
 
-        assert(found);
+    while (true) {
+        auto tickStart = m_clock->currentSteadyTime();
+        m_eventLoopMutex.lock();
+        step();
+
+        // Stop the event loop if the project has finished running (and untilProjectStops is set to true)
+        if (untilProjectStops && m_threads.empty()) {
+            m_eventLoopMutex.unlock();
+            break;
+        }
 
-        // Remove from globalScriptMap
-        for (auto &[target, scripts] : globalScriptMap) {
-            auto it = std::find_if(scripts.begin(), scripts.end(), pred);
+        // Stop the event loop if stopEventLoop() was called
+        m_stopEventLoopMutex.lock();
 
-            if (it != scripts.end()) {
-                scripts.erase(it);
-                break;
-            }
+        if (m_stopEventLoop) {
+            m_stopEventLoopMutex.unlock();
+            m_eventLoopMutex.unlock();
+            break;
         }
 
-        // Remove from m_runningBroadcastMap
-        for (auto &[broadcast, pairs] : m_runningBroadcastMap) {
-            size_t index = 0;
+        m_stopEventLoopMutex.unlock();
 
-            for (const auto &pair : pairs) {
-                if (pair.second == script) {
-                    pairs.erase(pairs.begin() + index);
-                    break;
-                }
+        std::chrono::steady_clock::time_point currentTime = m_clock->currentSteadyTime();
+        std::chrono::milliseconds elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - tickStart);
+        std::chrono::milliseconds sleepTime = m_frameDuration - elapsedTime;
+        m_eventLoopMutex.unlock();
 
-                index++;
-            }
-        }
+        // If there's any time left, sleep
+        if (sleepTime > std::chrono::milliseconds::zero())
+            m_clock->sleep(sleepTime);
     }
-    m_scriptsToRemove.clear();
+
+    finalize();
 }
 
 bool Engine::isRunning() const
@@ -478,8 +422,10 @@ double Engine::fps() const
 
 void Engine::setFps(double fps)
 {
-    m_fps = fps;
-    updateFrameDuration();
+    if (fps > 0) {
+        m_fps = std::min(fps, 250.0);
+        updateFrameDuration();
+    }
 }
 
 bool Engine::turboModeEnabled() const
@@ -527,15 +473,8 @@ void Engine::setKeyState(const KeyEvent &event, bool pressed)
 
     // Start "when key pressed" scripts
     if (pressed) {
-        auto it = m_whenKeyPressedScripts.find(event.name());
-
-        if (it != m_whenKeyPressedScripts.cend())
-            startHats(it->second);
-
-        it = m_whenKeyPressedScripts.find("any");
-
-        if (it != m_whenKeyPressedScripts.cend())
-            startHats(it->second);
+        startHats(HatType::KeyPressed, { { HatField::KeyOption, event.name() } }, nullptr);
+        startHats(HatType::KeyPressed, { { HatField::KeyOption, "any" } }, nullptr);
     }
 }
 
@@ -544,12 +483,8 @@ void Engine::setAnyKeyPressed(bool pressed)
     m_anyKeyPressed = pressed;
 
     // Start "when key pressed" scripts
-    if (pressed) {
-        auto it = m_whenKeyPressedScripts.find("any");
-
-        if (it != m_whenKeyPressedScripts.cend())
-            startHats(it->second);
-    }
+    if (pressed)
+        startHats(HatType::KeyPressed, { { HatField::KeyOption, "any" } }, nullptr);
 }
 
 double Engine::mouseX() const
@@ -632,28 +567,54 @@ void Engine::setSpriteFencingEnabled(bool enable)
     m_spriteFencingEnabled = enable;
 }
 
-bool Engine::broadcastRunning(unsigned int index, VirtualMachine *sourceScript)
+bool Engine::broadcastRunning(unsigned int index)
 {
     if (index < 0 || index >= m_broadcasts.size())
         return false;
 
-    return broadcastByPtrRunning(m_broadcasts[index].get(), sourceScript);
+    return broadcastByPtrRunning(m_broadcasts[index].get());
 }
 
-bool Engine::broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceScript)
+bool Engine::broadcastByPtrRunning(Broadcast *broadcast)
 {
-    auto it = m_runningBroadcastMap.find(broadcast);
+    if (broadcast->isBackdropBroadcast()) {
+        // This broadcast belongs to a backdrop
+        assert(m_broadcastMap.find(broadcast) == m_broadcastMap.cend());
 
-    if (it == m_runningBroadcastMap.cend())
-        return false;
+        for (auto thread : m_threads) {
+            if (!thread->atEnd()) {
+                Script *script = thread->script();
+                auto topBlock = script->topBlock();
 
-    const auto &scripts = it->second;
+                const auto &scripts = m_backdropChangeHats[script->target()];
+                auto scriptIt = std::find(scripts.begin(), scripts.end(), script);
+                auto scriptFieldMapIt = m_scriptHatFields.find(script);
 
-    for (const auto &pair : scripts) {
-        if (pair.first == sourceScript)
-            return true;
-    }
+                if (scriptFieldMapIt != m_scriptHatFields.cend()) {
+                    const auto &fieldMap = scriptFieldMapIt->second;
+                    auto fieldIt = fieldMap.find(HatField::Backdrop);
+                    assert(fieldIt != fieldMap.cend());
+                    assert(topBlock->findFieldById(fieldIt->second));
+
+                    if ((scriptIt != scripts.end()) && (topBlock->findFieldById(fieldIt->second)->value().toString() == broadcast->name()))
+                        return true;
+                }
+            }
+        }
+    } else {
+        // This is a regular broadcast
+        assert(m_broadcastMap.find(broadcast) != m_broadcastMap.cend());
+        const auto &scripts = m_broadcastMap[broadcast];
 
+        for (auto thread : m_threads) {
+            if (!thread->atEnd()) {
+                auto it = std::find_if(scripts.begin(), scripts.end(), [thread](Script *script) { return thread->script() == script; });
+
+                if (it != scripts.end())
+                    return true;
+            }
+        }
+    }
     return false;
 }
 
@@ -784,51 +745,47 @@ int Engine::findBroadcastById(const std::string &broadcastId) const
     return -1;
 }
 
-void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast)
+void Engine::addGreenFlagScript(std::shared_ptr<Block> hatBlock)
 {
-    if (m_broadcastMap.count(broadcast) == 1) {
-        std::vector<Script *> &scripts = m_broadcastMap[broadcast];
-        // TODO: Do not allow adding existing scripts
-        scripts.push_back(m_scripts[whenReceivedBlock].get());
-    } else {
-        m_broadcastMap[broadcast] = { m_scripts[whenReceivedBlock].get() };
-
-        // Create a vector of running scripts for this broadcast
-        // so we don't need to check if it's there
-        m_runningBroadcastMap[broadcast] = {};
-    }
+    addHatToMap(m_greenFlagHats, m_scripts[hatBlock].get());
 }
 
-void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
+void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, int fieldId, Broadcast *broadcast)
 {
-    Target *target = hatBlock->target();
-    Script *script = m_scripts[hatBlock].get();
-    auto it = m_cloneInitScriptsMap.find(target);
+    assert(!broadcast->isBackdropBroadcast());
+    Script *script = m_scripts[whenReceivedBlock].get();
+    auto it = m_broadcastMap.find(broadcast);
 
-    if (it == m_cloneInitScriptsMap.cend())
-        m_cloneInitScriptsMap[target] = { script };
-    else {
+    if (it != m_broadcastMap.cend()) {
         auto &scripts = it->second;
+        auto scriptIt = std::find(scripts.begin(), scripts.end(), script);
 
-        if (std::find(scripts.begin(), scripts.end(), script) == scripts.cend())
+        if (scriptIt == scripts.end())
             scripts.push_back(script);
-    }
+    } else
+        m_broadcastMap[broadcast] = { script };
+
+    addHatToMap(m_broadcastHats, script);
+    addHatField(script, HatField::BroadcastOption, fieldId);
 }
 
-void Engine::addKeyPressScript(std::shared_ptr<Block> hatBlock, std::string keyName)
+void Engine::addBackdropChangeScript(std::shared_ptr<Block> hatBlock, int fieldId)
 {
-    std::transform(keyName.begin(), keyName.end(), keyName.begin(), ::tolower);
     Script *script = m_scripts[hatBlock].get();
-    auto it = m_whenKeyPressedScripts.find(keyName);
+    addHatToMap(m_backdropChangeHats, script);
+    addHatField(script, HatField::Backdrop, fieldId);
+}
 
-    if (it == m_whenKeyPressedScripts.cend())
-        m_whenKeyPressedScripts[keyName] = { script };
-    else {
-        auto &scripts = it->second;
+void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
+{
+    addHatToMap(m_cloneInitHats, m_scripts[hatBlock].get());
+}
 
-        if (std::find(scripts.begin(), scripts.end(), script) == scripts.cend())
-            scripts.push_back(script);
-    }
+void Engine::addKeyPressScript(std::shared_ptr<Block> hatBlock, int fieldId)
+{
+    Script *script = m_scripts[hatBlock].get();
+    addHatToMap(m_whenKeyPressedHats, script);
+    addHatField(script, HatField::KeyOption, fieldId);
 }
 
 const std::vector<std::shared_ptr<Target>> &Engine::targets() const
@@ -1121,6 +1078,73 @@ std::shared_ptr<IBlockSection> Engine::blockSection(const std::string &opcode) c
     return nullptr;
 }
 
+void Engine::addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &map, Script *script)
+{
+    if (!script)
+        return;
+
+    assert(script->target());
+    Target *target = script->target();
+    auto it = map.find(target);
+
+    if (it != map.cend()) {
+        auto &scripts = it->second;
+        auto scriptIt = std::find(scripts.begin(), scripts.end(), script);
+
+        if (scriptIt == scripts.end())
+            scripts.push_back(script);
+    } else
+        map[target] = { script };
+}
+
+void Engine::addHatField(Script *script, HatField field, int fieldId)
+{
+    auto it = m_scriptHatFields.find(script);
+
+    if (it == m_scriptHatFields.cend())
+        m_scriptHatFields[script] = { { field, fieldId } };
+    else {
+        auto &fieldMap = it->second;
+        fieldMap[field] = fieldId;
+    }
+}
+
+const std::vector<Script *> &Engine::getHats(Target *target, HatType type)
+{
+    assert(target);
+
+    // Get root if this is a clone
+    if (!target->isStage()) {
+        Sprite *sprite = dynamic_cast<Sprite *>(target);
+        assert(sprite);
+
+        if (sprite->isClone())
+            target = sprite->cloneSprite();
+    }
+
+    switch (type) {
+        case HatType::GreenFlag:
+            return m_greenFlagHats[target];
+
+        case HatType::BroadcastReceived:
+            return m_broadcastHats[target];
+
+        case HatType::BackdropChanged:
+            return m_backdropChangeHats[target];
+
+        case HatType::CloneInit:
+            return m_cloneInitHats[target];
+
+        case HatType::KeyPressed:
+            return m_whenKeyPressedHats[target];
+
+        default: {
+            static const std::vector<Script *> empty = {};
+            return empty;
+        }
+    }
+}
+
 void Engine::updateSpriteLayerOrder()
 {
     assert(m_executableTargets.empty() || m_executableTargets[0]->isStage());
@@ -1156,8 +1180,7 @@ BlockSectionContainer *Engine::blockSectionContainer(IBlockSection *section) con
 void Engine::finalize()
 {
     m_eventLoopMutex.lock();
-    m_runningScripts.clear();
-    m_scriptsToRemove.clear();
+    m_threads.clear();
     m_running = false;
     m_redrawRequested = false;
     m_eventLoopMutex.unlock();
@@ -1199,86 +1222,152 @@ void Engine::updateFrameDuration()
 
 void Engine::addRunningScript(std::shared_ptr<VirtualMachine> vm)
 {
-    Target *target = vm->target();
-    assert(vm->target());
-    auto it1 = m_runningScripts.find(target);
-    auto it2 = m_newScripts.find(target);
+    m_threads.push_back(vm);
+}
 
-    if (it1 == m_runningScripts.cend())
-        m_runningScripts[target] = { vm };
-    else {
-        assert(std::find(it1->second.begin(), it1->second.end(), vm) == it1->second.end());
-        it1->second.push_back(vm);
+std::shared_ptr<VirtualMachine> Engine::pushThread(std::shared_ptr<Block> block, Target *target)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1649-L1661
+    if (!block) {
+        std::cerr << "error: tried to start a script with a null block" << std::endl;
+        assert(false);
+        return nullptr;
     }
 
-    if (it2 == m_newScripts.cend())
-        m_newScripts[target] = { vm };
-    else {
-        assert(std::find(it2->second.begin(), it2->second.end(), vm) == it2->second.end());
-        it2->second.push_back(vm);
+    if (!target) {
+        std::cerr << "error: scripts must be started by a target" << std::endl;
+        assert(false);
+        return nullptr;
     }
+
+    auto script = m_scripts[block];
+    std::shared_ptr<VirtualMachine> vm = script->start(target);
+    addRunningScript(vm);
+    return vm;
 }
 
-std::vector<VirtualMachine *> Engine::startHats(const std::vector<Script *> &scripts)
+void Engine::stopThread(VirtualMachine *thread)
 {
-    std::vector<VirtualMachine *> startedScripts;
-
-    for (auto script : scripts) {
-        std::vector<VirtualMachine *> runningScripts;
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1667-L1672
+    assert(thread);
+    thread->kill();
+}
 
-        for (const auto &[target, targetScripts] : m_runningScripts) {
-            for (auto vm : targetScripts) {
-                if (vm->script() == script) {
-                    runningScripts.push_back(vm.get());
-                }
-            }
-        }
+std::shared_ptr<VirtualMachine> Engine::restartThread(std::shared_ptr<VirtualMachine> thread)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1681C30-L1694
+    std::shared_ptr<VirtualMachine> newThread = thread->script()->start(thread->target());
+    auto it = std::find(m_threads.begin(), m_threads.end(), thread);
 
-        // Reset running scripts
-        for (VirtualMachine *vm : runningScripts) {
-            vm->reset();
+    if (it != m_threads.end()) {
+        auto i = it - m_threads.begin();
+        m_threads[i] = newThread;
+        return newThread;
+    }
 
-            // Remove the script from scripts to remove because it's going to run again
-            m_scriptsToRemove.erase(std::remove(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm), m_scriptsToRemove.end());
-            assert(std::find(m_scriptsToRemove.begin(), m_scriptsToRemove.end(), vm) == m_scriptsToRemove.end());
-        }
+    addRunningScript(thread);
+    return thread;
+}
 
-        // Start scripts which are not running
-        Target *root = script->target();
-        std::vector<Target *> targets = { root };
+template<typename F>
+void Engine::allScriptsByOpcodeDo(HatType hatType, F &&f, Target *optTarget)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1797-L1809
+    std::vector<Target *> *targetsPtr = &m_executableTargets;
 
-        if (!root->isStage()) {
-            Sprite *sprite = dynamic_cast<Sprite *>(root);
-            assert(sprite);
-            assert(!sprite->isClone());
-            const auto &children = sprite->clones();
+    if (optTarget)
+        targetsPtr = new std::vector<Target *>({ optTarget });
 
-            for (auto child : children)
-                targets.push_back(child.get());
-        }
+    const std::vector<Target *> targets = *targetsPtr;
 
-        for (Target *target : targets) {
-            std::shared_ptr<Block> block = nullptr;
+    for (int t = targets.size() - 1; t >= 0; t--) {
+        Target *target = targets[t];
+        const auto &scripts = getHats(target, hatType);
 
-            if (!runningScripts.empty()) {
-                auto it = std::find_if(runningScripts.begin(), runningScripts.end(), [target, script](VirtualMachine *vm) { return (vm->target() == target) && (vm->script() == script); });
+        for (size_t j = 0; j < scripts.size(); j++)
+            f(scripts[j], target);
+    }
 
-                if (it != runningScripts.end())
-                    continue; // skip the script because it was already running and was reset
+    if (optTarget)
+        delete targetsPtr;
+}
+
+std::vector<std::shared_ptr<VirtualMachine>>
+Engine::startHats(HatType hatType, const std::unordered_map<HatField, std::variant<std::string, const char *, Entity *>> &optMatchFields, Target *optTarget)
+{
+    // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1818-L1889
+    std::vector<std::shared_ptr<VirtualMachine>> newThreads;
+
+    allScriptsByOpcodeDo(
+        hatType,
+        [this, hatType, &optMatchFields, &newThreads](Script *script, Target *target) {
+            auto topBlock = script->topBlock();
+
+            if (!optMatchFields.empty()) {
+                // Get the field map for this script
+                auto fieldMapIt = m_scriptHatFields.find(script);
+                assert(fieldMapIt != m_scriptHatFields.cend());
+
+                if (fieldMapIt != m_scriptHatFields.cend()) {
+                    const auto &fieldMap = fieldMapIt->second;
+
+                    // Match any requested fields
+                    for (const auto &[fieldId, fieldValue] : optMatchFields) {
+                        auto fieldIt = fieldMap.find(fieldId);
+                        assert(fieldIt != fieldMap.cend());
+
+                        if (fieldIt != fieldMap.cend()) {
+                            assert(topBlock->findFieldById(fieldIt->second));
+
+                            if (std::holds_alternative<std::string>(fieldValue)) {
+                                if (topBlock->findFieldById(fieldIt->second)->value().toString() != std::get<std::string>(fieldValue)) {
+                                    // Field mismatch
+                                    return;
+                                }
+                            } else if (std::holds_alternative<const char *>(fieldValue)) {
+                                if (topBlock->findFieldById(fieldIt->second)->value().toString() != std::string(std::get<const char *>(fieldValue))) {
+                                    // Field mismatch
+                                    return;
+                                }
+                            } else {
+                                if (topBlock->findFieldById(fieldIt->second)->valuePtr().get() != std::get<Entity *>(fieldValue)) {
+                                    // Field mismatch
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
             }
 
-            for (const auto &[b, s] : m_scripts) {
-                if (s.get() == script) {
-                    block = b;
-                    break;
+            if (m_hatRestartExistingThreads.at(hatType)) {
+                // Restart existing threads
+                for (auto thread : m_threads) {
+                    if (thread->target() == target && thread->script() == script) {
+                        newThreads.push_back(restartThread(thread));
+                        return;
+                    }
+                }
+            } else {
+                // Give up if any threads with the top block are running
+                for (auto thread : m_threads) {
+                    if (thread->target() == target && thread->script() == script && !thread->atEnd()) {
+                        // Some thread is already running
+                        return;
+                    }
                 }
             }
 
-            assert(block);
-            assert(std::find_if(m_targets.begin(), m_targets.end(), [script](std::shared_ptr<Target> target) { return script->target() == target.get(); }) != m_targets.end());
-            startedScripts.push_back(startScript(block, target));
-        }
-    }
+            // Start the thread with this top block
+            newThreads.push_back(pushThread(topBlock, target));
+        },
+        optTarget);
+
+    // Run edge-triggered hats (for compatibility with Scratch 2)
+    // TODO: Find out what "edge-triggered" hats are and execute them
+    // Uncommenting this would cause infinite recursion in some cases, so let's keep it commented
+    /*for (auto thread : newThreads)
+        thread->run();*/
 
-    return startedScripts;
+    return newThreads;
 }
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index a04c158b..8bc4f47d 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -10,6 +10,7 @@
 #include <chrono>
 #include <mutex>
 #include <set>
+#include <variant>
 
 #include "blocksectioncontainer.h"
 
@@ -33,8 +34,9 @@ class Engine : public IEngine
         void start() override;
         void stop() override;
         VirtualMachine *startScript(std::shared_ptr<Block> topLevelBlock, Target *target) override;
-        void broadcast(unsigned int index, VirtualMachine *sourceScript, bool wait = false) override;
-        void broadcastByPtr(Broadcast *broadcast, VirtualMachine *sourceScript, bool wait = false) override;
+        void broadcast(unsigned int index) override;
+        void broadcastByPtr(Broadcast *broadcast) override;
+        void startBackdropScripts(Broadcast *broadcast) override;
         void stopScript(VirtualMachine *vm) override;
         void stopTarget(Target *target, VirtualMachine *exceptScript) override;
         void initClone(std::shared_ptr<Sprite> clone) override;
@@ -84,8 +86,8 @@ class Engine : public IEngine
         bool spriteFencingEnabled() const override;
         void setSpriteFencingEnabled(bool enable) override;
 
-        bool broadcastRunning(unsigned int index, VirtualMachine *sourceScript) override;
-        bool broadcastByPtrRunning(Broadcast *broadcast, VirtualMachine *sourceScript) override;
+        bool broadcastRunning(unsigned int index) override;
+        bool broadcastByPtrRunning(Broadcast *broadcast) override;
 
         void requestRedraw() override;
 
@@ -108,9 +110,11 @@ class Engine : public IEngine
         int findBroadcast(const std::string &broadcastName) const override;
         int findBroadcastById(const std::string &broadcastId) const override;
 
-        void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Broadcast *broadcast) override;
+        void addGreenFlagScript(std::shared_ptr<Block> hatBlock) override;
+        void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, int fieldId, Broadcast *broadcast) override;
+        void addBackdropChangeScript(std::shared_ptr<Block> hatBlock, int fieldId) override;
         void addCloneInitScript(std::shared_ptr<Block> hatBlock) override;
-        void addKeyPressScript(std::shared_ptr<Block> hatBlock, std::string keyName) override;
+        void addKeyPressScript(std::shared_ptr<Block> hatBlock, int fieldId) override;
 
         const std::vector<std::shared_ptr<Target>> &targets() const override;
         void setTargets(const std::vector<std::shared_ptr<Target>> &newTargets) override;
@@ -136,10 +140,26 @@ class Engine : public IEngine
         IClock *m_clock = nullptr;
 
     private:
-        using TargetScriptMap = std::unordered_map<Target *, std::vector<std::shared_ptr<VirtualMachine>>>;
-
+        enum class HatType
+        {
+            GreenFlag,
+            BroadcastReceived,
+            BackdropChanged,
+            CloneInit,
+            KeyPressed
+        };
+
+        enum class HatField
+        {
+            BroadcastOption,
+            Backdrop,
+            KeyOption
+        };
+
+        void step();
+        std::vector<std::shared_ptr<VirtualMachine>> stepThreads();
+        void stepThread(std::shared_ptr<VirtualMachine> thread);
         void eventLoop(bool untilProjectStops = false);
-        void runScripts(const TargetScriptMap &scriptMap, TargetScriptMap &globalScriptMap);
         void finalize();
         void deleteClones();
         void removeExecutableClones();
@@ -151,28 +171,48 @@ class Engine : public IEngine
         std::shared_ptr<Entity> getEntity(const std::string &id);
         std::shared_ptr<IBlockSection> blockSection(const std::string &opcode) const;
 
+        void addHatToMap(std::unordered_map<Target *, std::vector<Script *>> &map, Script *script);
+        void addHatField(Script *script, HatField field, int fieldId);
+        const std::vector<libscratchcpp::Script *> &getHats(Target *target, HatType type);
+
         void updateSpriteLayerOrder();
 
         void updateFrameDuration();
         void addRunningScript(std::shared_ptr<VirtualMachine> vm);
-        std::vector<VirtualMachine *> startHats(const std::vector<Script *> &scripts);
+
+        std::shared_ptr<VirtualMachine> pushThread(std::shared_ptr<Block> block, Target *target);
+        void stopThread(VirtualMachine *thread);
+        std::shared_ptr<VirtualMachine> restartThread(std::shared_ptr<VirtualMachine> thread);
+
+        template<typename F>
+        void allScriptsByOpcodeDo(HatType hatType, F &&f, Target *optTarget);
+
+        std::vector<std::shared_ptr<VirtualMachine>>
+        startHats(HatType hatType, const std::unordered_map<HatField, std::variant<std::string, const char *, Entity *>> &optMatchFields, Target *optTarget);
+
+        static const std::unordered_map<HatType, bool> m_hatRestartExistingThreads; // used to check whether a hat should restart existing threads
 
         std::unordered_map<std::shared_ptr<IBlockSection>, std::unique_ptr<BlockSectionContainer>> m_sections;
         std::vector<std::shared_ptr<Target>> m_targets;
         std::vector<std::shared_ptr<Broadcast>> m_broadcasts;
         std::unordered_map<Broadcast *, std::vector<Script *>> m_broadcastMap;
-        std::unordered_map<Broadcast *, std::vector<std::pair<VirtualMachine *, VirtualMachine *>>> m_runningBroadcastMap; // source script, "when received" script
-        std::unordered_map<Target *, std::vector<Script *>> m_cloneInitScriptsMap;                                         // target (no clones), "when I start as a clone" scripts
-        std::unordered_map<std::string, std::vector<Script *>> m_whenKeyPressedScripts;                                    // key name, "when key pressed" scripts
         std::vector<std::string> m_extensions;
         std::vector<Target *> m_executableTargets; // sorted by layer (reverse order of execution)
-        TargetScriptMap m_runningScripts;
-        TargetScriptMap m_newScripts;
-        std::vector<VirtualMachine *> m_scriptsToRemove;
+        std::vector<std::shared_ptr<VirtualMachine>> m_threads;
+        std::vector<std::shared_ptr<VirtualMachine>> m_threadsToStop;
+        std::shared_ptr<VirtualMachine> m_activeThread;
         std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> m_scripts;
         std::vector<BlockFunc> m_functions;
         std::recursive_mutex m_eventLoopMutex;
 
+        std::unordered_map<Target *, std::vector<Script *>> m_greenFlagHats;
+        std::unordered_map<Target *, std::vector<Script *>> m_backdropChangeHats;
+        std::unordered_map<Target *, std::vector<Script *>> m_broadcastHats;
+        std::unordered_map<Target *, std::vector<Script *>> m_cloneInitHats;
+        std::unordered_map<Target *, std::vector<Script *>> m_whenKeyPressedHats;
+
+        std::unordered_map<Script *, std::unordered_map<HatField, int>> m_scriptHatFields; // HatField, field ID from the block implementation
+
         std::unique_ptr<ITimer> m_defaultTimer;
         ITimer *m_timer = nullptr;
         double m_fps = 30;                         // default FPS
diff --git a/src/engine/script.cpp b/src/engine/script.cpp
index 82afea52..52d4df6b 100644
--- a/src/engine/script.cpp
+++ b/src/engine/script.cpp
@@ -13,8 +13,8 @@
 using namespace libscratchcpp;
 
 /*! Constructs Script. */
-Script::Script(Target *target, IEngine *engine) :
-    impl(spimpl::make_unique_impl<ScriptPrivate>(target, engine))
+Script::Script(Target *target, std::shared_ptr<Block> topBlock, IEngine *engine) :
+    impl(spimpl::make_unique_impl<ScriptPrivate>(target, topBlock, engine))
 {
 }
 
@@ -24,6 +24,11 @@ Target *Script::target() const
     return impl->target;
 }
 
+std::shared_ptr<Block> Script::topBlock() const
+{
+    return impl->topBlock;
+}
+
 /*! Returns the bytecode array. */
 unsigned int *Script::bytecode() const
 {
diff --git a/src/engine/script_p.cpp b/src/engine/script_p.cpp
index b4a9839e..fff08764 100644
--- a/src/engine/script_p.cpp
+++ b/src/engine/script_p.cpp
@@ -4,8 +4,9 @@
 
 using namespace libscratchcpp;
 
-ScriptPrivate::ScriptPrivate(Target *target, IEngine *engine) :
+ScriptPrivate::ScriptPrivate(Target *target, std::shared_ptr<Block> topBlock, IEngine *engine) :
     target(target),
+    topBlock(topBlock),
     engine(engine)
 {
 }
diff --git a/src/engine/script_p.h b/src/engine/script_p.h
index f80e30ad..b21d6517 100644
--- a/src/engine/script_p.h
+++ b/src/engine/script_p.h
@@ -3,25 +3,28 @@
 #pragma once
 
 #include <vector>
+#include <memory>
 #include <scratchcpp/value.h>
 
 namespace libscratchcpp
 {
 
 class Target;
+class Block;
 class IEngine;
 class Variable;
 class List;
 
 struct ScriptPrivate
 {
-        ScriptPrivate(Target *target, IEngine *engine);
+        ScriptPrivate(Target *target, std::shared_ptr<Block> topBlock, IEngine *engine);
         ScriptPrivate(const ScriptPrivate &) = delete;
 
         unsigned int *bytecode = nullptr;
         std::vector<unsigned int> bytecodeVector;
 
         Target *target = nullptr;
+        std::shared_ptr<Block> topBlock;
         IEngine *engine = nullptr;
 
         unsigned int **procedures = nullptr;
diff --git a/src/engine/virtualmachine.cpp b/src/engine/virtualmachine.cpp
index 24a01de1..46f6fa5f 100644
--- a/src/engine/virtualmachine.cpp
+++ b/src/engine/virtualmachine.cpp
@@ -175,6 +175,13 @@ void VirtualMachine::run()
     impl->running = false;
 }
 
+/*! Stops the execution and sets atEnd to true. */
+void VirtualMachine::kill()
+{
+    reset();
+    impl->atEnd = true;
+}
+
 /*! Jumps back to the initial position. */
 void VirtualMachine::reset()
 {
diff --git a/src/scratch/broadcast.cpp b/src/scratch/broadcast.cpp
index 4c2c6328..582a3f8f 100644
--- a/src/scratch/broadcast.cpp
+++ b/src/scratch/broadcast.cpp
@@ -7,9 +7,9 @@
 using namespace libscratchcpp;
 
 /*! Constructs Broadcast. */
-Broadcast::Broadcast(const std::string &id, const std::string &name) :
+Broadcast::Broadcast(const std::string &id, const std::string &name, bool isBackdropBroadcast) :
     Entity(id),
-    impl(spimpl::make_unique_impl<BroadcastPrivate>(name))
+    impl(spimpl::make_unique_impl<BroadcastPrivate>(name, isBackdropBroadcast))
 {
 }
 
@@ -24,3 +24,9 @@ void Broadcast::setName(const std::string &newName)
 {
     impl->name = newName;
 }
+
+/*! Returns true if this broadcast belongs to a backdrop. */
+bool Broadcast::isBackdropBroadcast() const
+{
+    return impl->isBackdropBroadcast;
+}
diff --git a/src/scratch/broadcast_p.cpp b/src/scratch/broadcast_p.cpp
index b6cb4f19..b6c055bc 100644
--- a/src/scratch/broadcast_p.cpp
+++ b/src/scratch/broadcast_p.cpp
@@ -5,8 +5,9 @@
 namespace libscratchcpp
 {
 
-BroadcastPrivate::BroadcastPrivate(const std::string &name) :
-    name(name)
+BroadcastPrivate::BroadcastPrivate(const std::string &name, bool isBackdropBroadcast) :
+    name(name),
+    isBackdropBroadcast(isBackdropBroadcast)
 {
 }
 
diff --git a/src/scratch/broadcast_p.h b/src/scratch/broadcast_p.h
index 830a5d57..6422d99f 100644
--- a/src/scratch/broadcast_p.h
+++ b/src/scratch/broadcast_p.h
@@ -9,10 +9,11 @@ namespace libscratchcpp
 
 struct BroadcastPrivate
 {
-        BroadcastPrivate(const std::string &name);
+        BroadcastPrivate(const std::string &name, bool isBackdropBroadcast);
         BroadcastPrivate(const BroadcastPrivate &) = delete;
 
         std::string name;
+        bool isBackdropBroadcast = false;
 };
 
 } // namespace libscratchcpp
diff --git a/src/scratch/costume.cpp b/src/scratch/costume.cpp
index b24da79f..df32fb35 100644
--- a/src/scratch/costume.cpp
+++ b/src/scratch/costume.cpp
@@ -12,6 +12,7 @@ Costume::Costume(const std::string &name, const std::string &id, const std::stri
     Asset(name, id, format),
     impl(spimpl::make_unique_impl<CostumePrivate>())
 {
+    impl->broadcast.setName(name);
 }
 
 /*! Returns the reciprocal of the costume scaling factor for bitmap costumes. */
diff --git a/src/scratch/costume_p.cpp b/src/scratch/costume_p.cpp
index 0b70f216..88dd0dac 100644
--- a/src/scratch/costume_p.cpp
+++ b/src/scratch/costume_p.cpp
@@ -5,6 +5,6 @@
 using namespace libscratchcpp;
 
 CostumePrivate::CostumePrivate() :
-    broadcast("", "")
+    broadcast("", "", true)
 {
 }
diff --git a/test/2_frames.sb3 b/test/2_frames.sb3
index 510a2d08..d89bb837 100644
Binary files a/test/2_frames.sb3 and b/test/2_frames.sb3 differ
diff --git a/test/assets/costume_test.cpp b/test/assets/costume_test.cpp
index 94a8a734..3ccceff4 100644
--- a/test/assets/costume_test.cpp
+++ b/test/assets/costume_test.cpp
@@ -55,5 +55,6 @@ TEST_F(CostumeTest, Broadcast)
     Broadcast *broadcast = costume.broadcast();
     ASSERT_TRUE(broadcast);
     ASSERT_TRUE(broadcast->id().empty());
-    ASSERT_TRUE(broadcast->name().empty());
+    ASSERT_EQ(broadcast->name(), "costume1");
+    ASSERT_TRUE(broadcast->isBackdropBroadcast());
 }
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
index 127f3294..60cbb47b 100644
--- a/test/blocks/event_blocks_test.cpp
+++ b/test/blocks/event_blocks_test.cpp
@@ -83,7 +83,7 @@ TEST_F(EventBlocksTest, CategoryVisible)
 TEST_F(EventBlocksTest, RegisterBlocks)
 {
     // Blocks
-    EXPECT_CALL(m_engineMock, addHatBlock(m_section.get(), "event_whenflagclicked"));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenflagclicked", &EventBlocks::compileWhenFlagClicked));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_broadcast", &EventBlocks::compileBroadcast));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_broadcastandwait", &EventBlocks::compileBroadcastAndWait));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "event_whenbroadcastreceived", &EventBlocks::compileWhenBroadcastReceived));
@@ -101,6 +101,26 @@ TEST_F(EventBlocksTest, RegisterBlocks)
     m_section->registerBlocks(&m_engineMock);
 }
 
+TEST_F(EventBlocksTest, WhenFlagClicked)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = createEventBlock("a", "event_whenflagclicked");
+
+    compiler.init();
+
+    EXPECT_CALL(m_engineMock, addGreenFlagScript(block));
+    compiler.setBlock(block);
+    EventBlocks::compileWhenFlagClicked(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+    ASSERT_TRUE(compiler.variables().empty());
+    ASSERT_TRUE(compiler.lists().empty());
+}
+
 TEST_F(EventBlocksTest, Broadcast)
 {
     Compiler compiler(&m_engineMock);
@@ -145,14 +165,14 @@ TEST_F(EventBlocksTest, BroadcastImpl)
     vm.setConstValues(constValues);
 
     EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, broadcast(1, &vm, false)).Times(1);
+    EXPECT_CALL(m_engineMock, broadcast(1)).Times(1);
 
     vm.setBytecode(bytecode1);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
 
-    EXPECT_CALL(m_engineMock, broadcast(2, &vm, false)).Times(1);
+    EXPECT_CALL(m_engineMock, broadcast(2)).Times(1);
 
     vm.setBytecode(bytecode2);
     vm.run();
@@ -210,7 +230,7 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     vm.setConstValues(constValues);
 
     EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, broadcast(1, &vm, true)).Times(1);
+    EXPECT_CALL(m_engineMock, broadcast(1)).Times(1);
 
     vm.setBytecode(bytecode1);
     vm.run();
@@ -218,7 +238,7 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     ASSERT_EQ(vm.registerCount(), 0);
 
     EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(2));
-    EXPECT_CALL(m_engineMock, broadcastRunning(2, &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastRunning(2)).WillOnce(Return(true));
 
     vm.setBytecode(bytecode2);
     vm.run();
@@ -227,21 +247,21 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     ASSERT_EQ(vm.atEnd(), false);
 
     EXPECT_CALL(m_engineMock, findBroadcast("test")).WillOnce(Return(2));
-    EXPECT_CALL(m_engineMock, broadcastRunning(2, &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastRunning(2)).WillOnce(Return(false));
 
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(vm.atEnd(), true);
 
-    EXPECT_CALL(m_engineMock, broadcast(3, &vm, true)).Times(1);
+    EXPECT_CALL(m_engineMock, broadcast(3)).Times(1);
 
     vm.setBytecode(bytecode3);
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
 
-    EXPECT_CALL(m_engineMock, broadcastRunning(3, &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, broadcastRunning(3)).WillOnce(Return(true));
 
     vm.setBytecode(bytecode4);
     vm.run();
@@ -249,7 +269,7 @@ TEST_F(EventBlocksTest, BroadcastAndWaitImpl)
     ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(vm.atEnd(), false);
 
-    EXPECT_CALL(m_engineMock, broadcastRunning(3, &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastRunning(3)).WillOnce(Return(false));
 
     vm.run();
 
@@ -265,7 +285,7 @@ TEST_F(EventBlocksTest, WhenBroadcastReceived)
     auto block1 = createEventBlock("a", "event_whenbroadcastreceived");
     addBroadcastField(block1, "BROADCAST_OPTION", EventBlocks::BROADCAST_OPTION, m_broadcast);
 
-    EXPECT_CALL(m_engineMock, addBroadcastScript(block1, m_broadcast.get())).Times(1);
+    EXPECT_CALL(m_engineMock, addBroadcastScript(block1, EventBlocks::BROADCAST_OPTION, m_broadcast.get())).Times(1);
 
     compiler.init();
     compiler.setBlock(block1);
@@ -290,8 +310,7 @@ TEST_F(EventBlocksTest, WhenBackdropSwitchesTo)
     auto backdrop = std::make_shared<Costume>("backdrop2", "a", "svg");
     stage.addCostume(backdrop);
 
-    EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, addBroadcastScript(block1, backdrop->broadcast()));
+    EXPECT_CALL(m_engineMock, addBackdropChangeScript(block1, EventBlocks::BACKDROP));
 
     compiler.init();
     compiler.setBlock(block1);
@@ -318,11 +337,11 @@ TEST_F(EventBlocksTest, WhenKeyPressed)
 
     compiler.init();
 
-    EXPECT_CALL(m_engineMock, addKeyPressScript(block1, "a"));
+    EXPECT_CALL(m_engineMock, addKeyPressScript(block1, EventBlocks::KEY_OPTION));
     compiler.setBlock(block1);
     EventBlocks::compileWhenKeyPressed(&compiler);
 
-    EXPECT_CALL(m_engineMock, addKeyPressScript(block2, "left arrow"));
+    EXPECT_CALL(m_engineMock, addKeyPressScript(block2, EventBlocks::KEY_OPTION));
     compiler.setBlock(block2);
     EventBlocks::compileWhenKeyPressed(&compiler);
 
diff --git a/test/blocks/looks_blocks_test.cpp b/test/blocks/looks_blocks_test.cpp
index a94e2b04..a9eb1e24 100644
--- a/test/blocks/looks_blocks_test.cpp
+++ b/test/blocks/looks_blocks_test.cpp
@@ -1580,7 +1580,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // "backdrop2"
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.setBytecode(bytecode1);
     vm.run();
 
@@ -1589,7 +1589,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 0
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.setBytecode(bytecode2);
     vm.run();
 
@@ -1599,7 +1599,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.setCostumeIndex(0);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1608,7 +1608,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 1
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.setBytecode(bytecode3);
     vm.run();
 
@@ -1617,7 +1617,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 2
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.setBytecode(bytecode4);
     vm.run();
 
@@ -1626,7 +1626,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 3
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.setBytecode(bytecode5);
     vm.run();
 
@@ -1641,7 +1641,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.setCostumeIndex(0);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     vm.setBytecode(bytecode6);
     vm.run();
 
@@ -1650,7 +1650,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // "next backdrop"
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(3)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
     vm.setBytecode(bytecode7);
     vm.run();
 
@@ -1658,7 +1658,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     ASSERT_EQ(stage.costumeIndex(), 3);
 
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1666,7 +1666,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     ASSERT_EQ(stage.costumeIndex(), 0);
 
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1676,7 +1676,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.addCostume(std::make_shared<Costume>("next backdrop", "b5", "svg"));
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(4)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1685,7 +1685,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // "previous backdrop"
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(3)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
     vm.setBytecode(bytecode8);
     vm.run();
 
@@ -1693,7 +1693,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     ASSERT_EQ(stage.costumeIndex(), 3);
 
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1703,7 +1703,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.setCostumeIndex(0);
 
     EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(4)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1713,7 +1713,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.addCostume(std::make_shared<Costume>("previous backdrop", "b6", "svg"));
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -1724,7 +1724,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
     stage.setCostumeIndex(1);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
     vm.setBytecode(bytecode9);
     vm.run();
 
@@ -1733,7 +1733,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 0 (index)
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.setBytecode(bytecode10);
     vm.run();
 
@@ -1742,7 +1742,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 5 (index)
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
     vm.setBytecode(bytecode11);
     vm.run();
 
@@ -1751,7 +1751,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToImpl)
 
     // 6 (index)
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.setBytecode(bytecode12);
     vm.run();
 
@@ -1821,6 +1821,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     // Test without any backdrops first
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block1);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1830,6 +1831,7 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block1);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1838,24 +1840,28 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block2);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block3);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block4);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block5);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1864,12 +1870,14 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block6);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::nextBackdropAndWait)).WillOnce(Return(1));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block7);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1878,12 +1886,14 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block8);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::previousBackdropAndWait)).WillOnce(Return(2));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block9);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1892,12 +1902,14 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block10);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::randomBackdropAndWait)).WillOnce(Return(3));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block11);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1906,12 +1918,14 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToByIndexAndWait)).WillOnce(Return(0));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block12);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::switchBackdropToAndWait)).WillOnce(Return(4));
+    EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::backdropNumber)).WillOnce(Return(6));
     EXPECT_CALL(m_engineMock, functionIndex(&LooksBlocks::checkBackdropScripts)).WillOnce(Return(5));
     compiler.setBlock(block13);
     LooksBlocks::compileSwitchBackdropToAndWait(&compiler);
@@ -1922,6 +1936,8 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
         compiler.bytecode(),
         std::vector<unsigned int>(
             { vm::OP_START,
+              vm::OP_EXEC,
+              6,
               vm::OP_EXEC,
               5,
               vm::OP_CONST,
@@ -1929,71 +1945,97 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               1,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               2,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               3,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               4,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               5,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_EXEC,
               1,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               6,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_EXEC,
               2,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               7,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_EXEC,
               3,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_CONST,
               8,
               vm::OP_EXEC,
               0,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_NULL,
               vm::OP_EXEC,
               4,
               vm::OP_EXEC,
+              6,
+              vm::OP_EXEC,
               5,
               vm::OP_HALT }));
     ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 1, -1, 0, 1, 3, 3, 4, 5, 6 }));
@@ -2001,19 +2043,19 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWait)
 
 TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 {
-    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode4[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode5[] = { vm::OP_START, vm::OP_CONST, 4, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode6[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode7[] = { vm::OP_START, vm::OP_CONST, 5, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode8[] = { vm::OP_START, vm::OP_CONST, 6, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode9[] = { vm::OP_START, vm::OP_CONST, 7, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode10[] = { vm::OP_START, vm::OP_CONST, 8, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode11[] = { vm::OP_START, vm::OP_CONST, 9, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static unsigned int bytecode12[] = { vm::OP_START, vm::OP_CONST, 10, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::switchBackdropToAndWait, &LooksBlocks::switchBackdropToByIndexAndWait, &LooksBlocks::checkBackdropScripts };
+    static unsigned int bytecode1[] = { vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode2[] = { vm::OP_START, vm::OP_CONST, 1, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode3[] = { vm::OP_START, vm::OP_CONST, 2, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode4[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode5[] = { vm::OP_START, vm::OP_CONST, 4, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode6[] = { vm::OP_START, vm::OP_CONST, 3, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode7[] = { vm::OP_START, vm::OP_CONST, 5, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode8[] = { vm::OP_START, vm::OP_CONST, 6, vm::OP_EXEC, 0, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode9[] = { vm::OP_START, vm::OP_CONST, 7, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode10[] = { vm::OP_START, vm::OP_CONST, 8, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode11[] = { vm::OP_START, vm::OP_CONST, 9, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static unsigned int bytecode12[] = { vm::OP_START, vm::OP_CONST, 10, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_EXEC, 3, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::switchBackdropToAndWait, &LooksBlocks::switchBackdropToByIndexAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
     static Value constValues[] = { "backdrop2", 0, 1, 2, 3, "next backdrop", "previous backdrop", -1, 0, 5, 6 };
 
     Target target;
@@ -2028,36 +2070,36 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     vm.setConstValues(constValues);
 
     // "backdrop2"
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
     vm.setBytecode(bytecode1);
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 1);
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(vm.atEnd());
 
     // 0
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
     vm.setBytecode(bytecode2);
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 1);
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
@@ -2065,9 +2107,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2076,9 +2118,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_TRUE(vm.atEnd());
 
     // 1
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode3);
     vm.run();
 
@@ -2087,9 +2129,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_TRUE(vm.atEnd());
 
     // 2
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode4);
     vm.run();
 
@@ -2097,9 +2139,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_EQ(stage.costumeIndex(), 1);
 
     // 3
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode5);
     vm.run();
 
@@ -2113,9 +2155,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     stage.addCostume(std::make_shared<Costume>("test", "b4", "svg"));
     stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode6);
     vm.run();
 
@@ -2123,35 +2165,35 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_EQ(stage.costumeIndex(), 2);
 
     // "next backdrop"
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(3)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(true));
     vm.setBytecode(bytecode7);
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 3);
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2160,9 +2202,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     stage.addCostume(std::make_shared<Costume>("next backdrop", "b5", "svg"));
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(4)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2170,26 +2212,28 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_EQ(stage.costumeIndex(), 4);
 
     // "previous backdrop"
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(3)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(3)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(true));
     vm.setBytecode(bytecode8);
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 3);
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(3)->broadcast())).WillOnce(Return(false));
+    stage.setCostumeIndex(2); // checkBackdropScripts() should still check index 3 even after changing the backdrop
     vm.run();
+    stage.setCostumeIndex(3);
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2198,9 +2242,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     stage.setCostumeIndex(0);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(4)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(5).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(4)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(4)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2209,9 +2253,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
 
     stage.addCostume(std::make_shared<Costume>("previous backdrop", "b6", "svg"));
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2221,27 +2265,27 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     // -1 (index)
     stage.setCostumeIndex(1);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(true));
     vm.setBytecode(bytecode9);
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 5);
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(vm.atEnd());
 
     // 0 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode10);
     vm.run();
 
@@ -2250,9 +2294,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_TRUE(vm.atEnd());
 
     // 5 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(5)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(5)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(5)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode11);
     vm.run();
 
@@ -2260,9 +2304,9 @@ TEST_F(LooksBlocksTest, SwitchBackdropToAndWaitImpl)
     ASSERT_EQ(stage.costumeIndex(), 5);
 
     // 6 (index)
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.setBytecode(bytecode12);
     vm.run();
 
@@ -2305,14 +2349,14 @@ TEST_F(LooksBlocksTest, NextBackdropImpl)
     vm.setFunctions(functions);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2320,7 +2364,7 @@ TEST_F(LooksBlocksTest, NextBackdropImpl)
     ASSERT_EQ(stage.costumeIndex(), 2);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2330,8 +2374,8 @@ TEST_F(LooksBlocksTest, NextBackdropImpl)
 
 TEST_F(LooksBlocksTest, NextBackdropAndWait)
 {
-    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::nextBackdropAndWait, &LooksBlocks::checkBackdropScripts };
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::nextBackdropAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
 
     Target target;
 
@@ -2345,25 +2389,25 @@ TEST_F(LooksBlocksTest, NextBackdropAndWait)
     vm.setBytecode(bytecode);
     vm.setFunctions(functions);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 1);
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2371,9 +2415,9 @@ TEST_F(LooksBlocksTest, NextBackdropAndWait)
     ASSERT_EQ(stage.costumeIndex(), 2);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2399,14 +2443,14 @@ TEST_F(LooksBlocksTest, PreviousBackdrop)
     vm.setFunctions(functions);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_EQ(stage.costumeIndex(), 1);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2414,7 +2458,7 @@ TEST_F(LooksBlocksTest, PreviousBackdrop)
     ASSERT_EQ(stage.costumeIndex(), 0);
 
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2424,8 +2468,8 @@ TEST_F(LooksBlocksTest, PreviousBackdrop)
 
 TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
 {
-    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::previousBackdropAndWait, &LooksBlocks::checkBackdropScripts };
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::previousBackdropAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
 
     Target target;
 
@@ -2439,25 +2483,25 @@ TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
     vm.setBytecode(bytecode);
     vm.setFunctions(functions);
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 1);
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(0)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(0)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(0)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2465,9 +2509,9 @@ TEST_F(LooksBlocksTest, PreviousBackdropAndWait)
     ASSERT_EQ(stage.costumeIndex(), 0);
     ASSERT_TRUE(vm.atEnd());
 
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
@@ -2503,7 +2547,7 @@ TEST_F(LooksBlocksTest, RandomBackdrop)
 
     EXPECT_CALL(rng, randint(0, 2)).WillOnce(Return(1));
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2514,7 +2558,7 @@ TEST_F(LooksBlocksTest, RandomBackdrop)
 
     EXPECT_CALL(rng, randint(0, 3)).WillOnce(Return(2));
     EXPECT_CALL(m_engineMock, stage()).Times(2).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, false));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
     vm.reset();
     vm.run();
 
@@ -2526,8 +2570,8 @@ TEST_F(LooksBlocksTest, RandomBackdrop)
 
 TEST_F(LooksBlocksTest, RandomBackdropAndWait)
 {
-    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_HALT };
-    static BlockFunc functions[] = { &LooksBlocks::randomBackdropAndWait, &LooksBlocks::checkBackdropScripts };
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_EXEC, 1, vm::OP_EXEC, 2, vm::OP_HALT };
+    static BlockFunc functions[] = { &LooksBlocks::randomBackdropAndWait, &LooksBlocks::backdropNumber, &LooksBlocks::checkBackdropScripts };
 
     Target target;
 
@@ -2541,7 +2585,7 @@ TEST_F(LooksBlocksTest, RandomBackdropAndWait)
     LooksBlocks::rng = &rng;
 
     EXPECT_CALL(rng, randint).Times(0);
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
     EXPECT_CALL(m_engineMock, broadcastByPtrRunning).Times(0);
     vm.run();
 
@@ -2552,18 +2596,18 @@ TEST_F(LooksBlocksTest, RandomBackdropAndWait)
     stage.addCostume(std::make_shared<Costume>("backdrop3", "b3", "svg"));
 
     EXPECT_CALL(rng, randint(0, 2)).WillOnce(Return(1));
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(1)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(true));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(1)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(true));
     vm.reset();
     vm.run();
 
-    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_EQ(vm.registerCount(), 1);
     ASSERT_EQ(stage.costumeIndex(), 1);
     ASSERT_FALSE(vm.atEnd());
 
     EXPECT_CALL(m_engineMock, stage()).WillOnce(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(1)->broadcast())).WillOnce(Return(false));
     vm.run();
 
     ASSERT_EQ(vm.registerCount(), 0);
@@ -2572,9 +2616,9 @@ TEST_F(LooksBlocksTest, RandomBackdropAndWait)
     stage.addCostume(std::make_shared<Costume>("backdrop4", "b4", "svg"));
 
     EXPECT_CALL(rng, randint(0, 3)).WillOnce(Return(2));
-    EXPECT_CALL(m_engineMock, stage()).Times(3).WillRepeatedly(Return(&stage));
-    EXPECT_CALL(m_engineMock, broadcastByPtr(stage.costumeAt(2)->broadcast(), &vm, true));
-    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast(), &vm)).WillOnce(Return(false));
+    EXPECT_CALL(m_engineMock, stage()).Times(4).WillRepeatedly(Return(&stage));
+    EXPECT_CALL(m_engineMock, startBackdropScripts(stage.costumeAt(2)->broadcast()));
+    EXPECT_CALL(m_engineMock, broadcastByPtrRunning(stage.costumeAt(2)->broadcast())).WillOnce(Return(false));
     vm.reset();
     vm.run();
 
diff --git a/test/clone_limit.sb3 b/test/clone_limit.sb3
index 75338c6e..30e2dfd8 100644
Binary files a/test/clone_limit.sb3 and b/test/clone_limit.sb3 differ
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 6aaea6fd..8b1e5438 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -87,6 +87,21 @@ TEST(EngineTest, Fps)
 
     engine.setFps(60.25);
     ASSERT_EQ(engine.fps(), 60.25);
+
+    engine.setFps(0);
+    ASSERT_EQ(engine.fps(), 60.25);
+
+    engine.setFps(-5);
+    ASSERT_EQ(engine.fps(), 60.25);
+
+    engine.setFps(250);
+    ASSERT_EQ(engine.fps(), 250);
+
+    engine.setFps(30);
+    ASSERT_EQ(engine.fps(), 30);
+
+    engine.setFps(300);
+    ASSERT_EQ(engine.fps(), 250);
 }
 
 TEST(EngineTest, FpsProject)
@@ -99,47 +114,65 @@ TEST(EngineTest, FpsProject)
     engine->m_clock = &clock;
 
     std::chrono::steady_clock::time_point time1(std::chrono::milliseconds(50));
-    std::chrono::steady_clock::time_point time2(std::chrono::milliseconds(75));
-    std::chrono::steady_clock::time_point time3(std::chrono::milliseconds(83));
-    std::chrono::steady_clock::time_point time4(std::chrono::milliseconds(116));
+    std::chrono::steady_clock::time_point time2(std::chrono::milliseconds(70));
+    std::chrono::steady_clock::time_point time3(std::chrono::milliseconds(75));
+    std::chrono::steady_clock::time_point time4(std::chrono::milliseconds(83));
+    std::chrono::steady_clock::time_point time5(std::chrono::milliseconds(116));
+    std::chrono::steady_clock::time_point time6(std::chrono::milliseconds(156));
     EXPECT_CALL(clock, currentSteadyTime())
-        .WillOnce(Return(time1))
-        .WillOnce(Return(time1))
-        .WillOnce(Return(time2))
-        .WillOnce(Return(time2))
-        .WillOnce(Return(time3))
-        .WillOnce(Return(time3))
-        .WillOnce(Return(time4))
-        .WillOnce(Return(time4));
-    EXPECT_CALL(clock, sleep(std::chrono::milliseconds(33)));
-    EXPECT_CALL(clock, sleep(std::chrono::milliseconds(25)));
+        .WillOnce(Return(time1)) // tick start (frame 1 of 2)
+        .WillOnce(Return(time1)) // step start
+        .WillOnce(Return(time2)) // step loop check
+        .WillOnce(Return(time3)) // step loop check (break)
+        .WillOnce(Return(time3)) // tick end (then sleep 8 ms)
+        .WillOnce(Return(time4)) // tick start (frame 2 of 2)
+        .WillOnce(Return(time4)) // step start
+        .WillOnce(Return(time4)) // step loop check
+        .WillOnce(Return(time5)) // step loop check (break)
+        .WillOnce(Return(time5)) // tick end (without sleeping)
+        .WillOnce(Return(time5)) // tick start
+        .WillOnce(Return(time5)) // step start
+        .WillOnce(Return(time5)) // step loop check
+        ;
+    EXPECT_CALL(clock, sleep(std::chrono::milliseconds(8)));
     p.run();
 
     engine->setFps(10);
     RedrawMock redrawMock;
     auto handler = std::bind(&RedrawMock::redraw, &redrawMock);
     engine->setRedrawHandler(std::function<void()>(handler));
-    std::chrono::steady_clock::time_point time5(std::chrono::milliseconds(100));
-    std::chrono::steady_clock::time_point time6(std::chrono::milliseconds(115));
-    std::chrono::steady_clock::time_point time7(std::chrono::milliseconds(200));
-    std::chrono::steady_clock::time_point time8(std::chrono::milliseconds(300));
+    std::chrono::steady_clock::time_point time7(std::chrono::milliseconds(100));
+    std::chrono::steady_clock::time_point time8(std::chrono::milliseconds(200));
+    std::chrono::steady_clock::time_point time9(std::chrono::milliseconds(300));
     EXPECT_CALL(clock, currentSteadyTime())
-        .WillOnce(Return(time5))
-        .WillOnce(Return(time5))
-        .WillOnce(Return(time6))
-        .WillOnce(Return(time6))
-        .WillOnce(Return(time7))
-        .WillOnce(Return(time7))
-        .WillOnce(Return(time8))
-        .WillOnce(Return(time8));
+        .WillOnce(Return(time7)) // tick start (frame 1 of 2)
+        .WillOnce(Return(time7)) // step start
+        .WillOnce(Return(time7)) // step loop check
+        .WillOnce(Return(time7)) // step loop check (break because of redraw request)
+        .WillOnce(Return(time7)) // tick end (then sleep 100 ms)
+        .WillOnce(Return(time8)) // tick start (frame 2 of 2)
+        .WillOnce(Return(time8)) // step start
+        .WillOnce(Return(time8)) // step loop check
+        .WillOnce(Return(time9)) // step loop check (break)
+        .WillOnce(Return(time9)) // tick end (without sleeping)
+        .WillOnce(Return(time9)) // tick start
+        .WillOnce(Return(time9)) // step start
+        .WillOnce(Return(time9)) // step loop check
+        ;
     EXPECT_CALL(clock, sleep(std::chrono::milliseconds(100)));
-    EXPECT_CALL(clock, sleep(std::chrono::milliseconds(15)));
-    EXPECT_CALL(redrawMock, redraw()).Times(4);
+    EXPECT_CALL(redrawMock, redraw()).Times(3);
     p.run();
 
     engine->setTurboModeEnabled(true);
-    EXPECT_CALL(clock, currentSteadyTime()).WillOnce(Return(time5)).WillOnce(Return(time5)).WillOnce(Return(time6)).WillOnce(Return(time6)).WillOnce(Return(time7)).WillOnce(Return(time8));
+    EXPECT_CALL(clock, currentSteadyTime())
+        .WillOnce(Return(time7)) // tick start
+        .WillOnce(Return(time7)) // step start
+        .WillOnce(Return(time7)) // step loop check
+        .WillOnce(Return(time7)) // step loop check
+        .WillOnce(Return(time7)) // step loop check
+        ;
     EXPECT_CALL(clock, sleep).Times(0);
+    EXPECT_CALL(redrawMock, redraw());
     p.run();
 }
 
@@ -1092,8 +1125,7 @@ TEST(EngineTest, CloneLimit)
     ASSERT_EQ(engine->cloneLimit(), 300);
     ASSERT_EQ(engine->cloneCount(), 0);
 
-    // TODO: Set "infinite" FPS and remove this (#254)
-    engine->setFps(100000);
+    engine->setTurboModeEnabled(true);
 
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
@@ -1147,18 +1179,18 @@ TEST(EngineTest, CloneLimit)
 
 TEST(EngineTest, BackdropBroadcasts)
 {
-    // TODO: Set "infinite" FPS (#254)
     Project p("backdrop_broadcasts.sb3");
     ASSERT_TRUE(p.load());
     p.run();
 
     auto engine = p.engine();
+    engine->setFps(1000);
 
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
 
     ASSERT_VAR(stage, "test1");
-    ASSERT_EQ(GET_VAR(stage, "test1")->value().toInt(), 5); // TODO: Find out why this isn't 4
+    ASSERT_EQ(GET_VAR(stage, "test1")->value().toInt(), 4);
     ASSERT_VAR(stage, "test2");
     ASSERT_EQ(GET_VAR(stage, "test2")->value().toInt(), 14);
     ASSERT_VAR(stage, "test3");
@@ -1171,18 +1203,18 @@ TEST(EngineTest, BackdropBroadcasts)
 
 TEST(EngineTest, BroadcastsProject)
 {
-    // TODO: Set "infinite" FPS (#254)
     Project p("broadcasts.sb3");
     ASSERT_TRUE(p.load());
     p.run();
 
     auto engine = p.engine();
+    engine->setFps(1000);
 
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
 
     ASSERT_VAR(stage, "test1");
-    ASSERT_EQ(GET_VAR(stage, "test1")->value().toInt(), 6); // TODO: Find out why this isn't 4 (the only difference between this and backdrops is that backdrop changes request redraw)
+    ASSERT_EQ(GET_VAR(stage, "test1")->value().toInt(), 4);
     ASSERT_VAR(stage, "test2");
     ASSERT_EQ(GET_VAR(stage, "test2")->value().toInt(), 14);
     ASSERT_VAR(stage, "test3");
@@ -1190,7 +1222,7 @@ TEST(EngineTest, BroadcastsProject)
     ASSERT_VAR(stage, "test4");
     ASSERT_EQ(GET_VAR(stage, "test4")->value().toInt(), 10);
     ASSERT_VAR(stage, "test5");
-    ASSERT_EQ(GET_VAR(stage, "test5")->value().toString(), "2 1 0 0"); // TODO: Find out why this isn't "2 2 0 0"
+    ASSERT_EQ(GET_VAR(stage, "test5")->value().toString(), "2 2 0 0");
 }
 
 TEST(EngineTest, StopAll)
@@ -1206,6 +1238,7 @@ TEST(EngineTest, StopAll)
 
     ASSERT_VAR(stage, "i");
     ASSERT_EQ(GET_VAR(stage, "i")->value().toInt(), 11);
+    ASSERT_FALSE(engine->isRunning());
 }
 
 TEST(EngineTest, StopOtherScriptsInSprite)
@@ -1251,12 +1284,12 @@ TEST(EngineTest, NoCrashOnBroadcastSelfCall)
 TEST(EngineTest, NoRefreshWhenCallingRunningBroadcast)
 {
     // Regtest for #257
-    // TODO: Set "infinite" FPS (#254)
     Project p("regtest_projects/257_double_broadcast_stop.sb3");
     ASSERT_TRUE(p.load());
     p.run();
 
     auto engine = p.engine();
+    engine->setFps(1000);
 
     Stage *stage = engine->stage();
     ASSERT_TRUE(stage);
diff --git a/test/load_project/load_project_test.cpp b/test/load_project/load_project_test.cpp
index 4e385ac7..2c6898e9 100644
--- a/test/load_project/load_project_test.cpp
+++ b/test/load_project/load_project_test.cpp
@@ -12,6 +12,7 @@
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/inputvalue.h>
 #include <scratchcpp/comment.h>
+#include <scratchcpp/broadcast.h>
 #include <projectdownloaderfactorymock.h>
 #include <projectdownloadermock.h>
 
@@ -498,6 +499,10 @@ TEST(LoadProjectTest, ProjectTest)
         ASSERT_EQ(engine->extensions().size(), 0);
         ASSERT_EQ(engine->broadcasts().size(), 1);
 
+        auto broadcast = engine->broadcastAt(0);
+        ASSERT_EQ(broadcast->name(), "message1");
+        ASSERT_FALSE(broadcast->isBackdropBroadcast());
+
         i++;
     }
 }
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index c950e772..19d24ff5 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -17,8 +17,9 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, start, (), (override));
         MOCK_METHOD(void, stop, (), (override));
         MOCK_METHOD(VirtualMachine *, startScript, (std::shared_ptr<Block>, Target *), (override));
-        MOCK_METHOD(void, broadcast, (unsigned int, VirtualMachine *, bool), (override));
-        MOCK_METHOD(void, broadcastByPtr, (Broadcast *, VirtualMachine *, bool), (override));
+        MOCK_METHOD(void, broadcast, (unsigned int), (override));
+        MOCK_METHOD(void, broadcastByPtr, (Broadcast *), (override));
+        MOCK_METHOD(void, startBackdropScripts, (Broadcast *), (override));
         MOCK_METHOD(void, stopScript, (VirtualMachine *), (override));
         MOCK_METHOD(void, stopTarget, (Target *, VirtualMachine *), (override));
         MOCK_METHOD(void, initClone, (std::shared_ptr<Sprite>), (override));
@@ -68,8 +69,8 @@ class EngineMock : public IEngine
         MOCK_METHOD(bool, spriteFencingEnabled, (), (const, override));
         MOCK_METHOD(void, setSpriteFencingEnabled, (bool), (override));
 
-        MOCK_METHOD(bool, broadcastRunning, (unsigned int, VirtualMachine *), (override));
-        MOCK_METHOD(bool, broadcastByPtrRunning, (Broadcast *, VirtualMachine *), (override));
+        MOCK_METHOD(bool, broadcastRunning, (unsigned int), (override));
+        MOCK_METHOD(bool, broadcastByPtrRunning, (Broadcast *), (override));
 
         MOCK_METHOD(void, requestRedraw, (), (override));
 
@@ -90,9 +91,11 @@ class EngineMock : public IEngine
         MOCK_METHOD(int, findBroadcast, (const std::string &), (const, override));
         MOCK_METHOD(int, findBroadcastById, (const std::string &), (const, override));
 
-        MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, Broadcast *), (override));
+        MOCK_METHOD(void, addGreenFlagScript, (std::shared_ptr<Block>), (override));
+        MOCK_METHOD(void, addBroadcastScript, (std::shared_ptr<Block>, int, Broadcast *), (override));
+        MOCK_METHOD(void, addBackdropChangeScript, (std::shared_ptr<Block>, int), (override));
         MOCK_METHOD(void, addCloneInitScript, (std::shared_ptr<Block>), (override));
-        MOCK_METHOD(void, addKeyPressScript, (std::shared_ptr<Block>, std::string), (override));
+        MOCK_METHOD(void, addKeyPressScript, (std::shared_ptr<Block>, int), (override));
 
         MOCK_METHOD(const std::vector<std::shared_ptr<Target>> &, targets, (), (const, override));
         MOCK_METHOD(void, setTargets, (const std::vector<std::shared_ptr<Target>> &), (override));
diff --git a/test/scratch_classes/broadcast_test.cpp b/test/scratch_classes/broadcast_test.cpp
index 36e45fea..e52ffac3 100644
--- a/test/scratch_classes/broadcast_test.cpp
+++ b/test/scratch_classes/broadcast_test.cpp
@@ -6,9 +6,26 @@ using namespace libscratchcpp;
 
 TEST(BroadcastTest, Constructors)
 {
-    Broadcast broadcast("a", "message1");
-    ASSERT_EQ(broadcast.id(), "a");
-    ASSERT_EQ(broadcast.name(), "message1");
+    {
+        Broadcast broadcast("a", "message1");
+        ASSERT_EQ(broadcast.id(), "a");
+        ASSERT_EQ(broadcast.name(), "message1");
+        ASSERT_FALSE(broadcast.isBackdropBroadcast());
+    }
+
+    {
+        Broadcast broadcast("a", "message1", false);
+        ASSERT_EQ(broadcast.id(), "a");
+        ASSERT_EQ(broadcast.name(), "message1");
+        ASSERT_FALSE(broadcast.isBackdropBroadcast());
+    }
+
+    {
+        Broadcast broadcast("a", "message1", true);
+        ASSERT_EQ(broadcast.id(), "a");
+        ASSERT_EQ(broadcast.name(), "message1");
+        ASSERT_TRUE(broadcast.isBackdropBroadcast());
+    }
 }
 
 TEST(BroadcastTest, Name)
diff --git a/test/script/script_test.cpp b/test/script/script_test.cpp
index 2847338f..760fa6f6 100644
--- a/test/script/script_test.cpp
+++ b/test/script/script_test.cpp
@@ -1,4 +1,5 @@
 #include <scratchcpp/script.h>
+#include <scratchcpp/block.h>
 #include <scratchcpp/virtualmachine.h>
 #include <scratchcpp/target.h>
 #include <scratchcpp/sprite.h>
@@ -22,13 +23,15 @@ class ScriptTest : public testing::Test
 
 TEST_F(ScriptTest, Constructors)
 {
-    Script script(&m_target, &m_engine);
+    auto block = std::make_shared<Block>("", "");
+    Script script(&m_target, block, &m_engine);
     ASSERT_EQ(script.target(), &m_target);
+    ASSERT_EQ(script.topBlock(), block);
 }
 
 TEST_F(ScriptTest, Bytecode)
 {
-    Script script(nullptr, nullptr);
+    Script script(nullptr, nullptr, nullptr);
     ASSERT_EQ(script.bytecode(), nullptr);
     ASSERT_TRUE(script.bytecodeVector().empty());
 
@@ -58,7 +61,7 @@ TEST_F(ScriptTest, Start)
     std::shared_ptr<List> list2 = std::make_unique<List>("d", "");
     static std::vector<List *> lists = { list1.get(), list2.get() };
 
-    Script script1(nullptr, nullptr);
+    Script script1(nullptr, nullptr, nullptr);
 
     std::shared_ptr<VirtualMachine> vm = script1.start();
     ASSERT_TRUE(vm);
@@ -71,14 +74,14 @@ TEST_F(ScriptTest, Start)
     ASSERT_EQ(vm->variables(), nullptr);
     ASSERT_EQ(vm->lists(), nullptr);
 
-    Script script2(&m_target, &m_engine);
+    Script script2(&m_target, nullptr, &m_engine);
 
     vm = script2.start();
     ASSERT_TRUE(vm);
     ASSERT_EQ(vm->target(), &m_target);
     ASSERT_EQ(vm->engine(), &m_engine);
 
-    Script script3(&m_target, &m_engine);
+    Script script3(&m_target, nullptr, &m_engine);
     script3.setBytecode(bytecode);
     script3.setProcedures(procedures);
     script3.setFunctions(functions);
@@ -120,7 +123,7 @@ TEST_F(ScriptTest, Start)
     EXPECT_CALL(m_engine, requestRedraw());
     auto clone = root.clone();
 
-    Script script4(&root, &m_engine);
+    Script script4(&root, nullptr, &m_engine);
     script4.setBytecode(bytecode);
     script4.setProcedures(procedures);
     script4.setFunctions(functions);
diff --git a/test/virtual_machine/virtual_machine_test.cpp b/test/virtual_machine/virtual_machine_test.cpp
index e4f4aeb8..587d562b 100644
--- a/test/virtual_machine/virtual_machine_test.cpp
+++ b/test/virtual_machine/virtual_machine_test.cpp
@@ -23,7 +23,7 @@ TEST(VirtualMachineTest, Constructors)
 
     Target target;
     Engine engine;
-    Script script(&target, &engine);
+    Script script(&target, nullptr, &engine);
     VirtualMachine vm2(&target, &engine, &script);
     ASSERT_EQ(vm2.target(), &target);
     ASSERT_EQ(vm2.engine(), &engine);
@@ -1590,7 +1590,7 @@ TEST(VirtualMachineTest, OP_WARP)
     ASSERT_EQ(vm.registerCount(), 0);
 }
 
-TEST(VirtualMachineTest, Reset)
+TEST(VirtualMachineTest, ResetAndKill)
 {
     static unsigned int bytecode1[] = { OP_START, OP_NULL, OP_EXEC, 0, OP_HALT };
     static unsigned int bytecode2[] = { OP_START, OP_NULL, OP_EXEC, 1, OP_HALT };
@@ -1629,6 +1629,14 @@ TEST(VirtualMachineTest, Reset)
 
     vm.reset();
     ASSERT_FALSE(vm.atEnd());
+
+    // kill()
+    vm.run();
+    ASSERT_FALSE(vm.atEnd());
+    ASSERT_EQ(vm.registerCount(), 1);
+    vm.kill();
+    ASSERT_EQ(vm.registerCount(), 0);
+    ASSERT_TRUE(vm.atEnd());
 }
 
 TEST(VirtualMachineTest, NoCrashWhenRepeatingZeroTimes)